version = (1, 2)

data = ({'kAISEnvFacade': 977,
  'kAddDoubleLinear': 5,
  'kAdskMaterial': 1067,
  'kAffect': 6,
  'kAimConstraint': 111,
  'kAimMatrix': 1139,
  'kAir': 257,
  'kAlignCurve': 41,
  'kAlignManip': 912,
  'kAlignSurface': 42,
  'kAmbientLight': 303,
  'kAngle': 270,
  'kAngleBetween': 21,
  'kAnimBlend': 794,
  'kAnimBlendInOut': 795,
  'kAnimCurve': 7,
  'kAnimCurveTimeToAngular': 8,
  'kAnimCurveTimeToDistance': 9,
  'kAnimCurveTimeToTime': 10,
  'kAnimCurveTimeToUnitless': 11,
  'kAnimCurveUnitlessToAngular': 12,
  'kAnimCurveUnitlessToDistance': 13,
  'kAnimCurveUnitlessToTime': 14,
  'kAnimCurveUnitlessToUnitless': 15,
  'kAnimLayer': 1020,
  'kAnisotropy': 622,
  'kAnnotation': 271,
  'kAnyGeometryVarGroup': 115,
  'kArcLength': 273,
  'kAreaLight': 305,
  'kArrayMapper': 528,
  'kArrowManip': 123,
  'kArubaTesselate': 1132,
  'kAssembly': 1081,
  'kAsset': 1018,
  'kAttachCurve': 43,
  'kAttachSurface': 44,
  'kAttribute': 565,
  'kAttribute2Double': 747,
  'kAttribute2Float': 748,
  'kAttribute2Int': 750,
  'kAttribute2Long': 750,
  'kAttribute2Short': 749,
  'kAttribute3Double': 751,
  'kAttribute3Float': 752,
  'kAttribute3Int': 754,
  'kAttribute3Long': 754,
  'kAttribute3Short': 753,
  'kAttribute4Double': 880,
  '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': 899,
  'kBezierCurve': 1054,
  'kBezierCurveData': 1055,
  'kBezierCurveToNurbs': 1057,
  'kBinaryData': 746,
  'kBirailSrf': 49,
  'kBlend': 27,
  'kBlendColorSet': 739,
  'kBlendColors': 31,
  'kBlendDevice': 30,
  'kBlendFalloff': 1141,
  'kBlendManip': 152,
  'kBlendMatrix': 1137,
  'kBlendNodeAdditiveRotation': 1033,
  'kBlendNodeAdditiveScale': 1032,
  'kBlendNodeBase': 1021,
  'kBlendNodeBoolean': 1022,
  'kBlendNodeDouble': 1023,
  'kBlendNodeDoubleAngle': 1024,
  'kBlendNodeDoubleLinear': 1025,
  'kBlendNodeEnum': 1026,
  'kBlendNodeFloat': 1027,
  'kBlendNodeFloatAngle': 1028,
  'kBlendNodeFloatLinear': 1029,
  'kBlendNodeInt16': 1030,
  'kBlendNodeInt32': 1031,
  'kBlendNodeTime': 1052,
  'kBlendShape': 336,
  'kBlendTwoAttr': 28,
  'kBlendWeighted': 29,
  'kBlindData': 756,
  'kBlindDataTemplate': 757,
  'kBlinn': 373,
  'kBlinnMaterial': 389,
  'kBoundary': 53,
  'kBox': 867,
  'kBoxData': 866,
  'kBrownian': 508,
  'kBrush': 765,
  'kBulge': 497,
  'kBulgeLattice': 338,
  'kBump': 32,
  'kBump3d': 33,
  'kButtonManip': 153,
  'kCacheBase': 999,
  'kCacheBlend': 1000,
  'kCacheFile': 987,
  'kCacheTrack': 1001,
  'kCacheableNode': 996,
  'kCaddyManipBase': 1110,
  'kCamera': 250,
  'kCameraManip': 154,
  'kCameraPlaneManip': 143,
  'kCameraSet': 1011,
  'kCameraView': 34,
  'kCenterManip': 134,
  'kChainToSpline': 35,
  'kCharacter': 688,
  'kCharacterMap': 803,
  'kCharacterMappingData': 742,
  'kCharacterOffset': 689,
  'kChecker': 498,
  'kChoice': 36,
  'kChooser': 772,
  'kCircle': 54,
  'kCircleManip': 126,
  'kCirclePointManip': 231,
  'kCircleSweepManip': 128,
  'kClampColor': 39,
  'kClientDevice': 1077,
  'kClip': 809,
  'kClipGhostShape': 1082,
  'kClipLibrary': 780,
  'kClipScheduler': 779,
  'kClipToGhostData': 1083,
  'kCloseCurve': 55,
  'kCloseSurface': 57,
  'kClosestPointOnMesh': 989,
  'kClosestPointOnSurface': 56,
  'kCloth': 499,
  'kCloud': 509,
  'kCluster': 251,
  'kClusterFilter': 347,
  'kClusterFlexor': 300,
  'kCoiManip': 155,
  'kCollision': 253,
  'kColorBackground': 24,
  'kColorMgtGlobals': 1101,
  'kColorProfile': 1066,
  'kCombinationShape': 337,
  'kCommCornerManip': 613,
  'kCommCornerOperManip': 614,
  'kCommEdgeOperManip': 611,
  'kCommEdgePtManip': 610,
  'kCommEdgeSegmentManip': 612,
  'kComponent': 535,
  'kComponentFalloff': 1144,
  'kComponentListData': 583,
  'kComponentManip': 674,
  'kComponentMatch': 1147,
  'kComposeMatrix': 1136,
  'kCompoundAttribute': 575,
  'kConcentricProjectionManip': 129,
  'kCondition': 37,
  'kCone': 96,
  'kConstraint': 932,
  'kContainer': 1013,
  'kContainerBase': 1068,
  'kContourProjectionManip': 1115,
  'kContrast': 38,
  'kControl': 486,
  'kControllerTag': 1128,
  'kCopyColorSet': 738,
  'kCopyUVSet': 807,
  'kCpManip': 156,
  'kCrater': 510,
  'kCreaseSet': 1090,
  'kCreate': 40,
  'kCreateBPManip': 837,
  'kCreateBezierManip': 1053,
  'kCreateCVManip': 157,
  'kCreateColorSet': 736,
  'kCreateEPManip': 158,
  'kCreateSectionManip': 824,
  'kCreateUVSet': 808,
  'kCrossSectionEditManip': 825,
  'kCrossSectionManager': 823,
  'kCubicProjectionManip': 130,
  'kCurve': 266,
  'kCurveCVComponent': 536,
  'kCurveCurveIntersect': 641,
  'kCurveEPComponent': 537,
  'kCurveEdManip': 159,
  'kCurveFromMeshCoM': 934,
  'kCurveFromMeshEdge': 640,
  'kCurveFromSubdivEdge': 836,
  'kCurveFromSubdivFace': 842,
  'kCurveFromSurface': 58,
  'kCurveFromSurfaceBnd': 59,
  'kCurveFromSurfaceCoS': 60,
  'kCurveFromSurfaceIso': 61,
  'kCurveInfo': 62,
  'kCurveKnotComponent': 538,
  'kCurveNormalizerAngle': 1003,
  'kCurveNormalizerLinear': 1004,
  'kCurveParamComponent': 539,
  'kCurveSegmentManip': 160,
  'kCurveVarGroup': 116,
  'kCustomEvaluatorClusterNode': 1130,
  'kCylinder': 98,
  'kCylindricalProjectionManip': 131,
  'kDOF': 323,
  'kDPbirailSrf': 50,
  'kDagContainer': 1069,
  'kDagNode': 107,
  'kDagPose': 690,
  'kDagSelectionItem': 562,
  'kData': 582,
  'kData2Double': 593,
  'kData2Float': 594,
  'kData2Int': 595,
  'kData2Long': 595,
  'kData2Short': 596,
  'kData3Double': 597,
  'kData3Float': 598,
  'kData3Int': 599,
  'kData3Long': 599,
  'kData3Short': 600,
  'kData4Double': 881,
  'kDblTrsManip': 190,
  'kDecayRegionCapComponent': 548,
  'kDecayRegionComponent': 549,
  'kDecomposeMatrix': 1135,
  'kDefaultLightList': 317,
  'kDeformBend': 625,
  'kDeformBendManip': 631,
  'kDeformFlare': 628,
  'kDeformFlareManip': 634,
  'kDeformFunc': 624,
  'kDeformSine': 629,
  'kDeformSineManip': 635,
  'kDeformSquash': 627,
  'kDeformSquashManip': 633,
  'kDeformTwist': 626,
  'kDeformTwistManip': 632,
  'kDeformWave': 630,
  'kDeformWaveManip': 636,
  'kDeleteColorSet': 737,
  'kDeleteComponent': 318,
  'kDeleteUVSet': 800,
  'kDeltaMush': 350,
  'kDependencyNode': 4,
  'kDetachCurve': 63,
  'kDetachSurface': 64,
  'kDiffuseMaterial': 387,
  'kDimension': 269,
  'kDimensionManip': 232,
  'kDirectedDisc': 276,
  'kDirectionManip': 161,
  'kDirectionalLight': 308,
  'kDiscManip': 132,
  'kDiskCache': 863,
  'kDispatchCompute': 319,
  'kDisplacementShader': 321,
  'kDisplayLayer': 733,
  'kDisplayLayerManager': 734,
  'kDistance': 272,
  'kDistanceBetween': 322,
  'kDistanceManip': 638,
  'kDofManip': 162,
  'kDoubleAngleAttribute': 567,
  'kDoubleArrayData': 584,
  'kDoubleIndexedComponent': 714,
  'kDoubleLinearAttribute': 569,
  'kDoubleShadingSwitch': 619,
  'kDrag': 258,
  'kDropOffFunction': 826,
  'kDropoffLocator': 282,
  'kDropoffManip': 163,
  'kDummy': 254,
  'kDummyConnectable': 324,
  'kDynAirManip': 724,
  'kDynArrayAttrsData': 729,
  'kDynAttenuationManip': 728,
  'kDynBase': 720,
  'kDynBaseFieldManip': 723,
  'kDynEmitterManip': 721,
  'kDynFieldsManip': 722,
  'kDynGlobals': 769,
  'kDynNewtonManip': 725,
  'kDynParticleSetComponent': 560,
  'kDynSpreadManip': 727,
  'kDynSweptGeometryData': 743,
  'kDynTurbulenceManip': 726,
  'kDynamicConstraint': 993,
  'kDynamicsController': 325,
  'kEdgeComponent': 545,
  'kEditCurve': 821,
  'kEditCurveManip': 822,
  'kEditMetadata': 1089,
  'kEditsManager': 1097,
  'kEmitter': 255,
  'kEnableManip': 136,
  'kEnumAttribute': 572,
  'kEnvBall': 491,
  'kEnvChrome': 493,
  'kEnvCube': 492,
  'kEnvFacade': 976,
  'kEnvFogMaterial': 381,
  'kEnvFogShape': 278,
  'kEnvSky': 494,
  'kEnvSphere': 495,
  'kExplodeNurbsShell': 692,
  'kExpression': 327,
  'kExtendCurve': 65,
  'kExtendCurveDistanceManip': 164,
  'kExtendSurface': 66,
  'kExtendSurfaceDistanceManip': 716,
  'kExtract': 328,
  'kExtrude': 67,
  'kExtrudeManip': 165,
  'kFFD': 339,
  'kFFblendSrf': 68,
  'kFFfilletSrf': 69,
  'kFacade': 974,
  'kFalloffEval': 1146,
  'kFfdDualBase': 340,
  'kField': 256,
  'kFileBackground': 25,
  'kFileTexture': 500,
  'kFilletCurve': 70,
  'kFilter': 329,
  'kFilterClosestSample': 330,
  'kFilterEuler': 331,
  'kFilterSimplify': 332,
  'kFitBspline': 71,
  'kFixedLineManip': 233,
  'kFlexor': 299,
  'kFloatAngleAttribute': 568,
  'kFloatArrayData': 1037,
  'kFloatLinearAttribute': 570,
  'kFloatMatrixAttribute': 579,
  'kFloatVectorArrayData': 1014,
  'kFlow': 72,
  'kFluid': 914,
  'kFluidData': 916,
  'kFluidEmitter': 920,
  'kFluidGeom': 915,
  'kFluidTexture2D': 909,
  'kFluidTexture3D': 908,
  'kFollicle': 935,
  'kForceUpdateManip': 695,
  'kFosterParent': 1092,
  'kFourByFourMatrix': 775,
  'kFractal': 501,
  'kFreePointManip': 133,
  'kFreePointTriadManip': 137,
  'kGammaCorrect': 333,
  'kGenericAttribute': 576,
  'kGeoConnectable': 326,
  'kGeoConnector': 922,
  'kGeomBind': 1100,
  'kGeometric': 265,
  'kGeometryConstraint': 113,
  'kGeometryData': 712,
  'kGeometryFilt': 334,
  'kGeometryOnLineManip': 142,
  'kGeometryVarGroup': 114,
  'kGlobalCacheControls': 862,
  'kGlobalStitch': 701,
  'kGranite': 511,
  'kGravity': 259,
  'kGreasePencilSequence': 1088,
  'kGreasePlane': 1086,
  'kGreasePlaneRenderShape': 1087,
  'kGrid': 502,
  'kGroundPlane': 290,
  'kGroupId': 356,
  'kGroupParts': 357,
  'kGuide': 358,
  'kGuideLine': 301,
  'kHairConstraint': 940,
  'kHairSystem': 936,
  'kHairTubeShader': 947,
  'kHandleRotateManip': 216,
  'kHardenPointCurve': 73,
  'kHardwareReflectionMap': 886,
  'kHardwareRenderGlobals': 527,
  'kHardwareRenderingGlobals': 1071,
  'kHeightField': 921,
  'kHikEffector': 961,
  'kHikFKJoint': 963,
  'kHikFloorContactMarker': 983,
  'kHikGroundPlane': 984,
  'kHikHandle': 965,
  'kHikIKEffector': 962,
  'kHikSolver': 964,
  'kHistorySwitch': 988,
  'kHsvToRgb': 359,
  'kHwShaderNode': 889,
  'kHyperGraphInfo': 360,
  'kHyperLayout': 361,
  'kHyperLayoutDG': 1005,
  'kHyperView': 362,
  'kIkEffector': 119,
  'kIkHandle': 120,
  'kIkRPManip': 167,
  'kIkSolver': 363,
  'kIkSplineManip': 166,
  'kIkSystem': 369,
  'kIllustratorCurve': 74,
  'kImageAdd': 659,
  'kImageBlur': 665,
  'kImageColorCorrect': 664,
  'kImageData': 653,
  'kImageDepth': 667,
  'kImageDiff': 660,
  'kImageDisplay': 668,
  'kImageFilter': 666,
  'kImageLoad': 654,
  'kImageMotionBlur': 670,
  'kImageMultiply': 661,
  'kImageNetDest': 657,
  'kImageNetSrc': 656,
  'kImageOver': 662,
  'kImagePlane': 370,
  'kImageRender': 658,
  'kImageSave': 655,
  'kImageSource': 791,
  'kImageUnder': 663,
  'kImageView': 669,
  'kImplicitCone': 894,
  'kImplicitSphere': 895,
  'kInsertKnotCrv': 75,
  'kInsertKnotSrf': 76,
  'kInstancer': 762,
  'kInt64ArrayData': 814,
  'kIntArrayData': 585,
  'kIntersectSurface': 77,
  'kInvalid': 0,
  'kIsoparmComponent': 540,
  'kIsoparmManip': 146,
  'kItemList': 564,
  'kJiggleDeformer': 861,
  'kJoint': 121,
  'kJointCluster': 349,
  'kJointClusterManip': 168,
  'kJointTranslateManip': 229,
  'kKeyframeDelta': 949,
  'kKeyframeDeltaAddRemove': 952,
  'kKeyframeDeltaBlockAddRemove': 953,
  'kKeyframeDeltaBreakdown': 957,
  'kKeyframeDeltaInfType': 954,
  'kKeyframeDeltaMove': 950,
  'kKeyframeDeltaScale': 951,
  'kKeyframeDeltaTangent': 955,
  'kKeyframeDeltaWeighted': 956,
  'kKeyframeRegionManip': 1002,
  'kKeyingGroup': 687,
  'kLambert': 371,
  'kLambertMaterial': 388,
  'kLast': 1148,
  'kLattice': 279,
  'kLatticeComponent': 546,
  'kLatticeData': 587,
  'kLatticeGeom': 280,
  'kLayeredShader': 376,
  'kLayeredTexture': 804,
  'kLeastSquares': 379,
  'kLeather': 512,
  'kLight': 302,
  'kLightDataAttribute': 577,
  'kLightFogMaterial': 380,
  'kLightInfo': 378,
  'kLightLink': 768,
  'kLightList': 382,
  'kLightManip': 169,
  'kLightProjectionGeometry': 234,
  'kLightSource': 383,
  'kLightSourceMaterial': 391,
  'kLimitManip': 135,
  'kLineArrowManip': 235,
  'kLineManip': 147,
  'kLineModifier': 978,
  'kLinearLight': 306,
  'kLocator': 281,
  'kLodGroup': 773,
  'kLodThresholds': 771,
  'kLookAt': 112,
  'kLuminance': 384,
  'kMCsolver': 364,
  'kMPbirailSrf': 51,
  'kMakeGroup': 385,
  'kMandelbrot': 1084,
  'kMandelbrot3D': 1085,
  'kManip2DContainer': 192,
  'kManipContainer': 148,
  'kManipulator': 230,
  'kManipulator2D': 205,
  'kManipulator3D': 122,
  'kMarble': 513,
  'kMarker': 283,
  'kMarkerManip': 210,
  'kMaterial': 386,
  'kMaterialFacade': 975,
  'kMaterialInfo': 392,
  'kMaterialTemplate': 393,
  'kMatrixAdd': 394,
  'kMatrixArrayData': 603,
  'kMatrixAttribute': 578,
  'kMatrixData': 588,
  'kMatrixFloatData': 672,
  'kMatrixHold': 395,
  'kMatrixMult': 396,
  'kMatrixPass': 397,
  'kMatrixWtAdd': 398,
  'kMembrane': 1038,
  'kMentalRayTexture': 942,
  'kMergeVertsToolManip': 1039,
  'kMesh': 296,
  'kMeshComponent': 550,
  'kMeshData': 589,
  'kMeshEdgeComponent': 551,
  'kMeshFaceVertComponent': 555,
  'kMeshFrEdgeComponent': 553,
  'kMeshGeom': 297,
  'kMeshMapComponent': 817,
  'kMeshPolygonComponent': 552,
  'kMeshVarGroup': 117,
  'kMeshVertComponent': 554,
  'kMeshVtxFaceComponent': 745,
  'kMessageAttribute': 580,
  'kMidModifier': 399,
  'kMidModifierWithMatrix': 400,
  'kModel': 3,
  'kModifyEdgeBaseManip': 838,
  'kModifyEdgeCrvManip': 829,
  'kModifyEdgeManip': 830,
  'kMorph': 352,
  'kMotionPath': 445,
  'kMotionPathManip': 170,
  'kMountain': 503,
  'kMoveUVShellManip2D': 710,
  'kMoveVertexManip': 763,
  'kMultDoubleLinear': 774,
  'kMultiSubVertexComponent': 558,
  'kMultilisterLight': 447,
  'kMultiplyDivide': 448,
  'kMute': 931,
  'kNBase': 998,
  'kNCloth': 1007,
  'kNComponent': 994,
  'kNId': 1036,
  'kNIdData': 1035,
  'kNLE': 1095,
  'kNObject': 1016,
  'kNObjectData': 1015,
  'kNParticle': 1008,
  'kNRigid': 1009,
  'kNamedObject': 2,
  'kNearestPointOnCurve': 1065,
  'kNewton': 260,
  'kNodeGraphEditorBookmarkInfo': 1118,
  'kNodeGraphEditorBookmarks': 1117,
  'kNodeGraphEditorInfo': 1116,
  'kNoise': 879,
  'kNonAmbientLight': 304,
  'kNonDagSelectionItem': 563,
  'kNonExtendedLight': 307,
  'kNonLinear': 623,
  'kNormalConstraint': 238,
  'kNucleus': 997,
  'kNumericAttribute': 566,
  'kNumericData': 592,
  'kNurbsBoolean': 693,
  'kNurbsCircular2PtArc': 643,
  'kNurbsCircular3PtArc': 642,
  'kNurbsCube': 80,
  'kNurbsCurve': 267,
  'kNurbsCurveData': 591,
  'kNurbsCurveGeom': 268,
  'kNurbsCurveToBezier': 1056,
  'kNurbsPlane': 79,
  'kNurbsSquare': 621,
  'kNurbsSurface': 294,
  'kNurbsSurfaceData': 590,
  'kNurbsSurfaceGeom': 295,
  'kNurbsTesselate': 78,
  'kNurbsToSubdiv': 760,
  'kObjectAttrFilter': 680,
  'kObjectBinFilter': 943,
  'kObjectFilter': 676,
  'kObjectMultiFilter': 677,
  'kObjectNameFilter': 678,
  'kObjectRenderFilter': 681,
  'kObjectScriptFilter': 682,
  'kObjectTypeFilter': 679,
  'kOcean': 875,
  'kOceanDeformer': 1126,
  'kOceanShader': 898,
  'kOffsetCos': 81,
  'kOffsetCosManip': 171,
  'kOffsetCurve': 82,
  'kOffsetCurveManip': 172,
  'kOffsetSurface': 644,
  'kOffsetSurfaceManip': 652,
  'kOldGeometryConstraint': 449,
  'kOpticalFX': 450,
  'kOrientConstraint': 239,
  'kOrientationComponent': 556,
  'kOrientationLocator': 286,
  'kOrientationMarker': 284,
  'kOrthoGrid': 291,
  'kPASolver': 365,
  'kPairBlend': 927,
  'kParamDimension': 275,
  'kParentConstraint': 242,
  'kParticle': 311,
  'kParticleAgeMapper': 451,
  'kParticleCloud': 452,
  'kParticleColorMapper': 453,
  'kParticleIncandecenceMapper': 454,
  'kParticleSamplerInfo': 806,
  'kParticleTransparencyMapper': 455,
  'kPartition': 456,
  'kPassContributionMap': 787,
  'kPfxGeometry': 945,
  'kPfxHair': 946,
  'kPfxToon': 971,
  'kPhong': 374,
  'kPhongExplorer': 375,
  'kPhongMaterial': 390,
  'kPickMatrix': 1138,
  'kPivotComponent': 541,
  'kPivotManip2D': 191,
  'kPlace2dTexture': 457,
  'kPlace3dTexture': 458,
  'kPlanarProjectionManip': 207,
  'kPlanarTrimSrf': 83,
  'kPlane': 288,
  'kPlugin': 581,
  'kPluginBlendShape': 1121,
  'kPluginCameraSet': 1012,
  'kPluginClientDevice': 1078,
  'kPluginConstraintNode': 1017,
  'kPluginData': 601,
  'kPluginDeformerNode': 615,
  'kPluginDependNode': 459,
  'kPluginEmitterNode': 731,
  'kPluginFieldNode': 730,
  'kPluginGeometryData': 767,
  'kPluginGeometryFilter': 1120,
  'kPluginHardwareShader': 890,
  'kPluginHwShaderNode': 891,
  'kPluginIkSolver': 761,
  'kPluginImagePlaneNode': 1006,
  'kPluginLocatorNode': 460,
  'kPluginManipContainer': 696,
  'kPluginManipulatorNode': 1034,
  'kPluginMotionPathNode': 446,
  'kPluginObjectSet': 924,
  'kPluginParticleAttributeMapperNode': 1010,
  'kPluginShape': 711,
  'kPluginSkinCluster': 1119,
  'kPluginSpringNode': 732,
  'kPluginThreadedDevice': 1079,
  'kPluginTransformNode': 913,
  'kPlusMinusAverage': 461,
  'kPointArrayData': 602,
  'kPointConstraint': 240,
  'kPointLight': 309,
  'kPointManip': 236,
  'kPointMatrixMult': 462,
  'kPointOnCurveInfo': 84,
  'kPointOnCurveManip': 208,
  'kPointOnLineManip': 211,
  'kPointOnPolyConstraint': 1060,
  'kPointOnSurfaceInfo': 85,
  'kPointOnSurfaceManip': 212,
  'kPoleVectorConstraint': 243,
  'kPolyAppend': 403,
  'kPolyAppendVertex': 796,
  'kPolyArrow': 979,
  'kPolyAutoProj': 851,
  'kPolyAutoProjManip': 967,
  'kPolyAverageVertex': 850,
  'kPolyBevel': 401,
  'kPolyBevel2': 1098,
  'kPolyBevel3': 1102,
  'kPolyBlindData': 758,
  'kPolyBoolOp': 617,
  'kPolyBridgeEdge': 995,
  'kPolyCBoolOp': 1099,
  'kPolyCaddyManip': 1111,
  'kPolyChipOff': 404,
  'kPolyCircularize': 1131,
  'kPolyClean': 1124,
  'kPolyCloseBorder': 405,
  'kPolyCollapseEdge': 406,
  'kPolyCollapseF': 407,
  'kPolyColorDel': 741,
  'kPolyColorMod': 740,
  'kPolyColorPerVertex': 735,
  'kPolyComponentData': 985,
  'kPolyCone': 437,
  'kPolyConnectComponents': 1061,
  'kPolyContourProj': 1114,
  'kPolyCreaseEdge': 959,
  'kPolyCreateFacet': 443,
  'kPolyCreateToolManip': 140,
  'kPolyCreator': 435,
  'kPolyCube': 438,
  'kPolyCut': 901,
  'kPolyCutManip': 905,
  'kPolyCutManipContainer': 904,
  'kPolyCylProj': 408,
  'kPolyCylinder': 439,
  'kPolyDelEdge': 409,
  'kPolyDelFacet': 410,
  'kPolyDelVertex': 411,
  'kPolyDuplicateEdge': 973,
  'kPolyEdgeToCurve': 1019,
  'kPolyEditEdgeFlow': 1091,
  'kPolyExtrudeEdge': 793,
  'kPolyExtrudeFacet': 412,
  'kPolyExtrudeManip': 1074,
  'kPolyExtrudeManipContainer': 1075,
  'kPolyExtrudeVertex': 926,
  'kPolyFlipEdge': 792,
  'kPolyFlipUV': 888,
  'kPolyHelix': 986,
  'kPolyHoleFace': 1059,
  'kPolyLayoutUV': 852,
  'kPolyMapCut': 413,
  'kPolyMapDel': 414,
  'kPolyMapSew': 415,
  'kPolyMapSewMove': 853,
  'kPolyMappingManip': 194,
  'kPolyMergeEdge': 416,
  'kPolyMergeFacet': 417,
  'kPolyMergeUV': 910,
  'kPolyMergeVert': 698,
  'kPolyMesh': 440,
  'kPolyMirror': 958,
  'kPolyMirrorManipContainer': 906,
  'kPolyModifierManip': 195,
  'kPolyModifierManipContainer': 1112,
  'kPolyMoveEdge': 418,
  'kPolyMoveFacet': 419,
  'kPolyMoveFacetUV': 420,
  'kPolyMoveUV': 421,
  'kPolyMoveUVManip': 193,
  'kPolyMoveVertex': 422,
  'kPolyMoveVertexManip': 196,
  'kPolyMoveVertexUV': 423,
  'kPolyNormal': 424,
  'kPolyNormalPerVertex': 759,
  'kPolyNormalizeUV': 887,
  'kPolyPassThru': 1122,
  'kPolyPinUV': 960,
  'kPolyPipe': 982,
  'kPolyPlanProj': 425,
  'kPolyPlatonicSolid': 981,
  'kPolyPoke': 902,
  'kPolyPokeManip': 907,
  'kPolyPrimitive': 436,
  'kPolyPrimitiveMisc': 980,
  'kPolyPrism': 968,
  'kPolyProj': 426,
  'kPolyProjectCurve': 1072,
  'kPolyProjectionManip': 174,
  'kPolyPyramid': 969,
  'kPolyQuad': 427,
  'kPolyReduce': 770,
  'kPolyRemesh': 1113,
  'kPolySelectEditFeedbackManip': 1042,
  'kPolySeparate': 463,
  'kPolySewEdge': 697,
  'kPolySmooth': 428,
  'kPolySmoothFacet': 699,
  'kPolySmoothProxy': 944,
  'kPolySoftEdge': 429,
  'kPolySphProj': 430,
  'kPolySphere': 441,
  'kPolySpinEdge': 1058,
  'kPolySplit': 431,
  'kPolySplitEdge': 815,
  'kPolySplitRing': 970,
  'kPolySplitToolManip': 141,
  'kPolySplitVert': 810,
  'kPolyStraightenUVBorder': 911,
  'kPolySubdEdge': 432,
  'kPolySubdFacet': 433,
  'kPolyToSubdiv': 685,
  'kPolyToolFeedbackManip': 1041,
  'kPolyToolFeedbackShape': 312,
  'kPolyTorus': 442,
  'kPolyTransfer': 849,
  'kPolyTriangulate': 434,
  'kPolyTweak': 402,
  'kPolyTweakUV': 709,
  'kPolyUVRectangle': 1070,
  'kPolyUnite': 444,
  'kPolyVertexNormalManip': 197,
  'kPolyWedgeFace': 903,
  'kPoseInterpolatorManager': 1127,
  'kPositionMarker': 285,
  'kPostProcessList': 464,
  'kPrecompExport': 788,
  'kPrimitive': 86,
  'kPrimitiveFalloff': 1140,
  'kProjectCurve': 87,
  'kProjectTangent': 88,
  'kProjectTangentManip': 177,
  'kProjection': 465,
  'kProjectionManip': 173,
  'kProjectionMultiManip': 176,
  'kProjectionUVManip': 175,
  'kPropModManip': 178,
  'kPropMoveTriadManip': 138,
  'kProximityPin': 991,
  'kProximityWrap': 354,
  'kProxy': 108,
  'kProxyManager': 966,
  'kPsdFileTexture': 948,
  'kQuadPtOnLineManip': 179,
  'kQuadShadingSwitch': 925,
  'kRBFsurface': 89,
  'kRPsolver': 367,
  'kRadial': 261,
  'kRadius': 274,
  'kRamp': 504,
  'kRampBackground': 26,
  'kRampShader': 896,
  'kRbfSrfManip': 180,
  'kReForm': 1129,
  'kRebuildCurve': 90,
  'kRebuildSurface': 91,
  'kRecord': 466,
  'kReference': 755,
  'kReflect': 372,
  'kRemapColor': 938,
  'kRemapHsv': 939,
  'kRemapValue': 937,
  'kRenderBox': 868,
  'kRenderCone': 97,
  'kRenderGlobals': 523,
  'kRenderGlobalsList': 524,
  'kRenderLayer': 785,
  'kRenderLayerManager': 786,
  'kRenderPass': 783,
  'kRenderPassSet': 784,
  'kRenderQuality': 525,
  'kRenderRect': 277,
  'kRenderSetup': 522,
  'kRenderSphere': 298,
  'kRenderTarget': 789,
  'kRenderUtilityList': 467,
  'kRenderedImageSource': 790,
  'kRenderingList': 1073,
  'kReorderUVSet': 1133,
  'kResolution': 526,
  'kResultCurve': 16,
  'kResultCurveTimeToAngular': 17,
  'kResultCurveTimeToDistance': 18,
  'kResultCurveTimeToTime': 19,
  'kResultCurveTimeToUnitless': 20,
  'kReverse': 468,
  'kReverseCrvManip': 182,
  'kReverseCurve': 92,
  'kReverseCurveManip': 181,
  'kReverseSurface': 93,
  'kReverseSurfaceManip': 183,
  'kRevolve': 94,
  'kRevolveManip': 184,
  'kRevolvedPrimitive': 95,
  'kRevolvedPrimitiveManip': 185,
  'kRgbToHsv': 469,
  'kRigid': 314,
  'kRigidConstraint': 313,
  'kRigidDeform': 341,
  'kRigidSolver': 470,
  'kRock': 514,
  'kRotateBoxManip': 214,
  'kRotateLimitsManip': 217,
  'kRotateManip': 215,
  'kRotateUVManip2D': 707,
  'kRoundConstantRadius': 645,
  'kRoundConstantRadiusManip': 648,
  'kRoundRadiusCrvManip': 647,
  'kRoundRadiusManip': 646,
  'kSCsolver': 366,
  'kSPbirailSrf': 52,
  'kSamplerInfo': 478,
  'kScaleConstraint': 244,
  'kScaleLimitsManip': 218,
  'kScaleManip': 219,
  'kScalePointManip': 831,
  'kScaleUVManip2D': 708,
  'kScalingBoxManip': 220,
  'kScreenAlignedCircleManip': 127,
  'kScript': 639,
  'kScriptManip': 221,
  'kSculpt': 342,
  'kSectionManip': 818,
  'kSelectionItem': 561,
  'kSelectionList': 608,
  'kSelectionListData': 675,
  'kSelectionListOperator': 683,
  'kSequenceManager': 1049,
  'kSequencer': 1050,
  'kSet': 471,
  'kSetGroupComponent': 559,
  'kSetRange': 474,
  'kSfRevolveManip': 841,
  'kShaderGlow': 475,
  'kShaderList': 476,
  'kShadingEngine': 320,
  'kShadingMap': 477,
  'kShape': 248,
  'kShapeEditorManager': 1125,
  'kShapeFragment': 479,
  'kShot': 1051,
  'kShrinkWrapFilter': 1096,
  'kSimpleVolumeShader': 480,
  'kSingleIndexedComponent': 713,
  'kSingleShadingSwitch': 618,
  'kSketchPlane': 289,
  'kSkin': 100,
  'kSkinBinding': 1062,
  'kSkinClusterFilter': 686,
  'kSkinShader': 673,
  'kSl60': 481,
  'kSmear': 917,
  'kSmoothCurve': 700,
  'kSmoothTangentSrf': 782,
  'kSnapUVManip2D': 1093,
  'kSnapshot': 482,
  'kSnapshotPath': 923,
  'kSnapshotShape': 859,
  'kSnow': 515,
  'kSoftMod': 252,
  'kSoftModFilter': 348,
  'kSoftModManip': 637,
  'kSolidFractal': 516,
  'kSolidify': 353,
  'kSphere': 99,
  'kSphereData': 604,
  'kSphericalProjectionManip': 222,
  'kSplineSolver': 368,
  'kSpotCylinderManip': 187,
  'kSpotLight': 310,
  'kSpotManip': 186,
  'kSpring': 315,
  'kSprite': 292,
  'kSquareSrf': 717,
  'kSquareSrfManip': 718,
  'kStandardSurface': 377,
  'kStateManip': 145,
  'kStencil': 505,
  'kStereoCameraMaster': 1048,
  'kStitchAsNurbsShell': 691,
  'kStitchSrf': 101,
  'kStitchSrfManip': 694,
  'kStoryBoard': 483,
  'kStringArrayData': 606,
  'kStringData': 605,
  'kStringShadingSwitch': 918,
  'kStroke': 764,
  'kStrokeGlobals': 766,
  'kStucco': 517,
  'kStudioClearCoat': 919,
  'kStyleCurve': 900,
  'kSubCurve': 102,
  'kSubSurface': 781,
  'kSubVertexComponent': 557,
  'kSubdAddTopology': 892,
  'kSubdAutoProj': 877,
  'kSubdBlindData': 802,
  'kSubdBoolean': 827,
  'kSubdCleanTopology': 893,
  'kSubdCloseBorder': 864,
  'kSubdDelFace': 858,
  'kSubdExtrudeFace': 839,
  'kSubdHierBlind': 801,
  'kSubdLayoutUV': 873,
  'kSubdMapCut': 872,
  'kSubdMapSewMove': 874,
  'kSubdMappingManip': 885,
  'kSubdMergeVert': 865,
  'kSubdModifier': 854,
  'kSubdModifyEdge': 828,
  'kSubdMoveEdge': 856,
  'kSubdMoveFace': 857,
  'kSubdMoveVertex': 855,
  'kSubdPlanProj': 882,
  'kSubdProjectionManip': 884,
  'kSubdSplitFace': 869,
  'kSubdSubdivideFace': 878,
  'kSubdTweak': 883,
  'kSubdTweakUV': 871,
  'kSubdiv': 684,
  'kSubdivCVComponent': 702,
  'kSubdivCollapse': 805,
  'kSubdivCompId': 798,
  'kSubdivData': 811,
  'kSubdivEdgeComponent': 703,
  'kSubdivFaceComponent': 704,
  'kSubdivGeom': 812,
  'kSubdivMapComponent': 860,
  'kSubdivReverseFaces': 816,
  'kSubdivSurfaceVarGroup': 840,
  'kSubdivToNurbs': 820,
  'kSubdivToPoly': 719,
  'kSummaryObject': 484,
  'kSuper': 485,
  'kSurface': 293,
  'kSurfaceCVComponent': 542,
  'kSurfaceEPComponent': 543,
  'kSurfaceEdManip': 777,
  'kSurfaceFaceComponent': 778,
  'kSurfaceInfo': 103,
  'kSurfaceKnotComponent': 544,
  'kSurfaceLuminance': 487,
  'kSurfaceRangeComponent': 547,
  'kSurfaceShader': 488,
  'kSurfaceVarGroup': 118,
  'kSymmetryConstraint': 241,
  'kSymmetryLocator': 833,
  'kSymmetryMapCurve': 835,
  'kSymmetryMapVector': 834,
  'kTangentConstraint': 245,
  'kTension': 351,
  'kTexLattice': 200,
  'kTexLatticeDeformManip': 199,
  'kTexSmoothManip': 201,
  'kTexSmudgeUVManip': 198,
  'kTextButtonManip': 651,
  'kTextCurves': 104,
  'kTextManip': 928,
  'kTexture2d': 496,
  'kTexture3d': 507,
  'kTextureBakeSet': 472,
  'kTextureDeformer': 343,
  'kTextureDeformerHandle': 344,
  'kTextureEnv': 490,
  'kTextureList': 489,
  'kTextureManip3D': 223,
  'kThreadedDevice': 1076,
  'kThreePointArcManip': 649,
  'kTime': 520,
  'kTimeAttribute': 571,
  'kTimeEditor': 1106,
  'kTimeEditorAnimSource': 1109,
  'kTimeEditorClip': 1105,
  'kTimeEditorClipBase': 1103,
  'kTimeEditorClipEvaluator': 1104,
  'kTimeEditorInterpolator': 1108,
  'kTimeEditorTracks': 1107,
  'kTimeFunction': 941,
  'kTimeToUnitConversion': 521,
  'kTimeWarp': 1080,
  'kToggleManip': 224,
  'kToggleOnLineManip': 144,
  'kToolContext': 1094,
  'kToonLineAttributes': 972,
  'kTorus': 616,
  'kTowPointManip': 139,
  'kTowPointOnCurveManip': 209,
  'kTowPointOnSurfaceManip': 776,
  'kTrackInfoManager': 1123,
  'kTransferAttributes': 992,
  'kTransferFalloff': 1143,
  'kTransform': 110,
  'kTransformBoxManip': 832,
  'kTransformGeometry': 609,
  'kTranslateBoxManip': 225,
  'kTranslateLimitsManip': 226,
  'kTranslateManip': 227,
  'kTranslateManip2D': 206,
  'kTranslateUVManip': 213,
  'kTranslateUVManip2D': 706,
  'kTriadManip': 237,
  'kTrim': 105,
  'kTrimLocator': 287,
  'kTrimManip': 228,
  'kTrimWithBoundaries': 933,
  'kTriplanarProjectionManip': 188,
  'kTripleIndexedComponent': 715,
  'kTripleShadingSwitch': 620,
  'kTrsInsertManip': 203,
  'kTrsManip': 189,
  'kTrsTransManip': 202,
  'kTrsXformManip': 204,
  'kTurbulence': 262,
  'kTweak': 345,
  'kTwoPointArcManip': 650,
  'kTxSl': 518,
  'kTypedAttribute': 574,
  'kUInt64ArrayData': 813,
  'kUVManip2D': 705,
  'kUVPin': 990,
  'kUfeProxyTransform': 1134,
  'kUint64SingleIndexedComponent': 1040,
  'kUintArrayData': 586,
  'kUnderWorld': 109,
  'kUniform': 263,
  'kUniformFalloff': 1142,
  'kUnitAttribute': 573,
  'kUnitConversion': 529,
  'kUnitToTimeConversion': 530,
  'kUnknown': 532,
  'kUnknownDag': 316,
  'kUnknownTransform': 246,
  'kUntrim': 106,
  'kUnused1': 843,
  'kUnused2': 844,
  'kUnused3': 845,
  'kUnused4': 846,
  'kUnused5': 847,
  'kUnused6': 848,
  'kUseBackground': 531,
  'kUvChooser': 797,
  'kVectorArrayData': 607,
  'kVectorProduct': 533,
  'kVertexBakeSet': 473,
  'kVertexWeightSet': 1064,
  'kViewColorManager': 671,
  'kViewManip': 929,
  'kVolumeAxis': 799,
  'kVolumeBindManip': 1063,
  'kVolumeFog': 870,
  'kVolumeLight': 897,
  'kVolumeNoise': 876,
  'kVolumeShader': 534,
  'kVortex': 264,
  'kWater': 506,
  'kWeightFunctionData': 1145,
  'kWeightGeometryFilt': 346,
  'kWire': 355,
  'kWood': 519,
  'kWorld': 247,
  'kWrapFilter': 744,
  'kWriteToColorBuffer': 1044,
  'kWriteToDepthBuffer': 1046,
  'kWriteToFrameBuffer': 1043,
  'kWriteToLabelBuffer': 1047,
  'kWriteToVectorBuffer': 1045,
  'kXformManip': 930,
  'kXsectionSubdivEdit': 819},
 {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: 'kMorph',
  353: 'kSolidify',
  354: 'kProximityWrap',
  355: 'kWire',
  356: 'kGroupId',
  357: 'kGroupParts',
  358: 'kGuide',
  359: 'kHsvToRgb',
  360: 'kHyperGraphInfo',
  361: 'kHyperLayout',
  362: 'kHyperView',
  363: 'kIkSolver',
  364: 'kMCsolver',
  365: 'kPASolver',
  366: 'kSCsolver',
  367: 'kRPsolver',
  368: 'kSplineSolver',
  369: 'kIkSystem',
  370: 'kImagePlane',
  371: 'kLambert',
  372: 'kReflect',
  373: 'kBlinn',
  374: 'kPhong',
  375: 'kPhongExplorer',
  376: 'kLayeredShader',
  377: 'kStandardSurface',
  378: 'kLightInfo',
  379: 'kLeastSquares',
  380: 'kLightFogMaterial',
  381: 'kEnvFogMaterial',
  382: 'kLightList',
  383: 'kLightSource',
  384: 'kLuminance',
  385: 'kMakeGroup',
  386: 'kMaterial',
  387: 'kDiffuseMaterial',
  388: 'kLambertMaterial',
  389: 'kBlinnMaterial',
  390: 'kPhongMaterial',
  391: 'kLightSourceMaterial',
  392: 'kMaterialInfo',
  393: 'kMaterialTemplate',
  394: 'kMatrixAdd',
  395: 'kMatrixHold',
  396: 'kMatrixMult',
  397: 'kMatrixPass',
  398: 'kMatrixWtAdd',
  399: 'kMidModifier',
  400: 'kMidModifierWithMatrix',
  401: 'kPolyBevel',
  402: 'kPolyTweak',
  403: 'kPolyAppend',
  404: 'kPolyChipOff',
  405: 'kPolyCloseBorder',
  406: 'kPolyCollapseEdge',
  407: 'kPolyCollapseF',
  408: 'kPolyCylProj',
  409: 'kPolyDelEdge',
  410: 'kPolyDelFacet',
  411: 'kPolyDelVertex',
  412: 'kPolyExtrudeFacet',
  413: 'kPolyMapCut',
  414: 'kPolyMapDel',
  415: 'kPolyMapSew',
  416: 'kPolyMergeEdge',
  417: 'kPolyMergeFacet',
  418: 'kPolyMoveEdge',
  419: 'kPolyMoveFacet',
  420: 'kPolyMoveFacetUV',
  421: 'kPolyMoveUV',
  422: 'kPolyMoveVertex',
  423: 'kPolyMoveVertexUV',
  424: 'kPolyNormal',
  425: 'kPolyPlanProj',
  426: 'kPolyProj',
  427: 'kPolyQuad',
  428: 'kPolySmooth',
  429: 'kPolySoftEdge',
  430: 'kPolySphProj',
  431: 'kPolySplit',
  432: 'kPolySubdEdge',
  433: 'kPolySubdFacet',
  434: 'kPolyTriangulate',
  435: 'kPolyCreator',
  436: 'kPolyPrimitive',
  437: 'kPolyCone',
  438: 'kPolyCube',
  439: 'kPolyCylinder',
  440: 'kPolyMesh',
  441: 'kPolySphere',
  442: 'kPolyTorus',
  443: 'kPolyCreateFacet',
  444: 'kPolyUnite',
  445: 'kMotionPath',
  446: 'kPluginMotionPathNode',
  447: 'kMultilisterLight',
  448: 'kMultiplyDivide',
  449: 'kOldGeometryConstraint',
  450: 'kOpticalFX',
  451: 'kParticleAgeMapper',
  452: 'kParticleCloud',
  453: 'kParticleColorMapper',
  454: 'kParticleIncandecenceMapper',
  455: 'kParticleTransparencyMapper',
  456: 'kPartition',
  457: 'kPlace2dTexture',
  458: 'kPlace3dTexture',
  459: 'kPluginDependNode',
  460: 'kPluginLocatorNode',
  461: 'kPlusMinusAverage',
  462: 'kPointMatrixMult',
  463: 'kPolySeparate',
  464: 'kPostProcessList',
  465: 'kProjection',
  466: 'kRecord',
  467: 'kRenderUtilityList',
  468: 'kReverse',
  469: 'kRgbToHsv',
  470: 'kRigidSolver',
  471: 'kSet',
  472: 'kTextureBakeSet',
  473: 'kVertexBakeSet',
  474: 'kSetRange',
  475: 'kShaderGlow',
  476: 'kShaderList',
  477: 'kShadingMap',
  478: 'kSamplerInfo',
  479: 'kShapeFragment',
  480: 'kSimpleVolumeShader',
  481: 'kSl60',
  482: 'kSnapshot',
  483: 'kStoryBoard',
  484: 'kSummaryObject',
  485: 'kSuper',
  486: 'kControl',
  487: 'kSurfaceLuminance',
  488: 'kSurfaceShader',
  489: 'kTextureList',
  490: 'kTextureEnv',
  491: 'kEnvBall',
  492: 'kEnvCube',
  493: 'kEnvChrome',
  494: 'kEnvSky',
  495: 'kEnvSphere',
  496: 'kTexture2d',
  497: 'kBulge',
  498: 'kChecker',
  499: 'kCloth',
  500: 'kFileTexture',
  501: 'kFractal',
  502: 'kGrid',
  503: 'kMountain',
  504: 'kRamp',
  505: 'kStencil',
  506: 'kWater',
  507: 'kTexture3d',
  508: 'kBrownian',
  509: 'kCloud',
  510: 'kCrater',
  511: 'kGranite',
  512: 'kLeather',
  513: 'kMarble',
  514: 'kRock',
  515: 'kSnow',
  516: 'kSolidFractal',
  517: 'kStucco',
  518: 'kTxSl',
  519: 'kWood',
  520: 'kTime',
  521: 'kTimeToUnitConversion',
  522: 'kRenderSetup',
  523: 'kRenderGlobals',
  524: 'kRenderGlobalsList',
  525: 'kRenderQuality',
  526: 'kResolution',
  527: 'kHardwareRenderGlobals',
  528: 'kArrayMapper',
  529: 'kUnitConversion',
  530: 'kUnitToTimeConversion',
  531: 'kUseBackground',
  532: 'kUnknown',
  533: 'kVectorProduct',
  534: 'kVolumeShader',
  535: 'kComponent',
  536: 'kCurveCVComponent',
  537: 'kCurveEPComponent',
  538: 'kCurveKnotComponent',
  539: 'kCurveParamComponent',
  540: 'kIsoparmComponent',
  541: 'kPivotComponent',
  542: 'kSurfaceCVComponent',
  543: 'kSurfaceEPComponent',
  544: 'kSurfaceKnotComponent',
  545: 'kEdgeComponent',
  546: 'kLatticeComponent',
  547: 'kSurfaceRangeComponent',
  548: 'kDecayRegionCapComponent',
  549: 'kDecayRegionComponent',
  550: 'kMeshComponent',
  551: 'kMeshEdgeComponent',
  552: 'kMeshPolygonComponent',
  553: 'kMeshFrEdgeComponent',
  554: 'kMeshVertComponent',
  555: 'kMeshFaceVertComponent',
  556: 'kOrientationComponent',
  557: 'kSubVertexComponent',
  558: 'kMultiSubVertexComponent',
  559: 'kSetGroupComponent',
  560: 'kDynParticleSetComponent',
  561: 'kSelectionItem',
  562: 'kDagSelectionItem',
  563: 'kNonDagSelectionItem',
  564: 'kItemList',
  565: 'kAttribute',
  566: 'kNumericAttribute',
  567: 'kDoubleAngleAttribute',
  568: 'kFloatAngleAttribute',
  569: 'kDoubleLinearAttribute',
  570: 'kFloatLinearAttribute',
  571: 'kTimeAttribute',
  572: 'kEnumAttribute',
  573: 'kUnitAttribute',
  574: 'kTypedAttribute',
  575: 'kCompoundAttribute',
  576: 'kGenericAttribute',
  577: 'kLightDataAttribute',
  578: 'kMatrixAttribute',
  579: 'kFloatMatrixAttribute',
  580: 'kMessageAttribute',
  581: 'kPlugin',
  582: 'kData',
  583: 'kComponentListData',
  584: 'kDoubleArrayData',
  585: 'kIntArrayData',
  586: 'kUintArrayData',
  587: 'kLatticeData',
  588: 'kMatrixData',
  589: 'kMeshData',
  590: 'kNurbsSurfaceData',
  591: 'kNurbsCurveData',
  592: 'kNumericData',
  593: 'kData2Double',
  594: 'kData2Float',
  595: 'kData2Int',
  596: 'kData2Short',
  597: 'kData3Double',
  598: 'kData3Float',
  599: 'kData3Int',
  600: 'kData3Short',
  601: 'kPluginData',
  602: 'kPointArrayData',
  603: 'kMatrixArrayData',
  604: 'kSphereData',
  605: 'kStringData',
  606: 'kStringArrayData',
  607: 'kVectorArrayData',
  608: 'kSelectionList',
  609: 'kTransformGeometry',
  610: 'kCommEdgePtManip',
  611: 'kCommEdgeOperManip',
  612: 'kCommEdgeSegmentManip',
  613: 'kCommCornerManip',
  614: 'kCommCornerOperManip',
  615: 'kPluginDeformerNode',
  616: 'kTorus',
  617: 'kPolyBoolOp',
  618: 'kSingleShadingSwitch',
  619: 'kDoubleShadingSwitch',
  620: 'kTripleShadingSwitch',
  621: 'kNurbsSquare',
  622: 'kAnisotropy',
  623: 'kNonLinear',
  624: 'kDeformFunc',
  625: 'kDeformBend',
  626: 'kDeformTwist',
  627: 'kDeformSquash',
  628: 'kDeformFlare',
  629: 'kDeformSine',
  630: 'kDeformWave',
  631: 'kDeformBendManip',
  632: 'kDeformTwistManip',
  633: 'kDeformSquashManip',
  634: 'kDeformFlareManip',
  635: 'kDeformSineManip',
  636: 'kDeformWaveManip',
  637: 'kSoftModManip',
  638: 'kDistanceManip',
  639: 'kScript',
  640: 'kCurveFromMeshEdge',
  641: 'kCurveCurveIntersect',
  642: 'kNurbsCircular3PtArc',
  643: 'kNurbsCircular2PtArc',
  644: 'kOffsetSurface',
  645: 'kRoundConstantRadius',
  646: 'kRoundRadiusManip',
  647: 'kRoundRadiusCrvManip',
  648: 'kRoundConstantRadiusManip',
  649: 'kThreePointArcManip',
  650: 'kTwoPointArcManip',
  651: 'kTextButtonManip',
  652: 'kOffsetSurfaceManip',
  653: 'kImageData',
  654: 'kImageLoad',
  655: 'kImageSave',
  656: 'kImageNetSrc',
  657: 'kImageNetDest',
  658: 'kImageRender',
  659: 'kImageAdd',
  660: 'kImageDiff',
  661: 'kImageMultiply',
  662: 'kImageOver',
  663: 'kImageUnder',
  664: 'kImageColorCorrect',
  665: 'kImageBlur',
  666: 'kImageFilter',
  667: 'kImageDepth',
  668: 'kImageDisplay',
  669: 'kImageView',
  670: 'kImageMotionBlur',
  671: 'kViewColorManager',
  672: 'kMatrixFloatData',
  673: 'kSkinShader',
  674: 'kComponentManip',
  675: 'kSelectionListData',
  676: 'kObjectFilter',
  677: 'kObjectMultiFilter',
  678: 'kObjectNameFilter',
  679: 'kObjectTypeFilter',
  680: 'kObjectAttrFilter',
  681: 'kObjectRenderFilter',
  682: 'kObjectScriptFilter',
  683: 'kSelectionListOperator',
  684: 'kSubdiv',
  685: 'kPolyToSubdiv',
  686: 'kSkinClusterFilter',
  687: 'kKeyingGroup',
  688: 'kCharacter',
  689: 'kCharacterOffset',
  690: 'kDagPose',
  691: 'kStitchAsNurbsShell',
  692: 'kExplodeNurbsShell',
  693: 'kNurbsBoolean',
  694: 'kStitchSrfManip',
  695: 'kForceUpdateManip',
  696: 'kPluginManipContainer',
  697: 'kPolySewEdge',
  698: 'kPolyMergeVert',
  699: 'kPolySmoothFacet',
  700: 'kSmoothCurve',
  701: 'kGlobalStitch',
  702: 'kSubdivCVComponent',
  703: 'kSubdivEdgeComponent',
  704: 'kSubdivFaceComponent',
  705: 'kUVManip2D',
  706: 'kTranslateUVManip2D',
  707: 'kRotateUVManip2D',
  708: 'kScaleUVManip2D',
  709: 'kPolyTweakUV',
  710: 'kMoveUVShellManip2D',
  711: 'kPluginShape',
  712: 'kGeometryData',
  713: 'kSingleIndexedComponent',
  714: 'kDoubleIndexedComponent',
  715: 'kTripleIndexedComponent',
  716: 'kExtendSurfaceDistanceManip',
  717: 'kSquareSrf',
  718: 'kSquareSrfManip',
  719: 'kSubdivToPoly',
  720: 'kDynBase',
  721: 'kDynEmitterManip',
  722: 'kDynFieldsManip',
  723: 'kDynBaseFieldManip',
  724: 'kDynAirManip',
  725: 'kDynNewtonManip',
  726: 'kDynTurbulenceManip',
  727: 'kDynSpreadManip',
  728: 'kDynAttenuationManip',
  729: 'kDynArrayAttrsData',
  730: 'kPluginFieldNode',
  731: 'kPluginEmitterNode',
  732: 'kPluginSpringNode',
  733: 'kDisplayLayer',
  734: 'kDisplayLayerManager',
  735: 'kPolyColorPerVertex',
  736: 'kCreateColorSet',
  737: 'kDeleteColorSet',
  738: 'kCopyColorSet',
  739: 'kBlendColorSet',
  740: 'kPolyColorMod',
  741: 'kPolyColorDel',
  742: 'kCharacterMappingData',
  743: 'kDynSweptGeometryData',
  744: 'kWrapFilter',
  745: 'kMeshVtxFaceComponent',
  746: 'kBinaryData',
  747: 'kAttribute2Double',
  748: 'kAttribute2Float',
  749: 'kAttribute2Short',
  750: 'kAttribute2Int',
  751: 'kAttribute3Double',
  752: 'kAttribute3Float',
  753: 'kAttribute3Short',
  754: 'kAttribute3Int',
  755: 'kReference',
  756: 'kBlindData',
  757: 'kBlindDataTemplate',
  758: 'kPolyBlindData',
  759: 'kPolyNormalPerVertex',
  760: 'kNurbsToSubdiv',
  761: 'kPluginIkSolver',
  762: 'kInstancer',
  763: 'kMoveVertexManip',
  764: 'kStroke',
  765: 'kBrush',
  766: 'kStrokeGlobals',
  767: 'kPluginGeometryData',
  768: 'kLightLink',
  769: 'kDynGlobals',
  770: 'kPolyReduce',
  771: 'kLodThresholds',
  772: 'kChooser',
  773: 'kLodGroup',
  774: 'kMultDoubleLinear',
  775: 'kFourByFourMatrix',
  776: 'kTowPointOnSurfaceManip',
  777: 'kSurfaceEdManip',
  778: 'kSurfaceFaceComponent',
  779: 'kClipScheduler',
  780: 'kClipLibrary',
  781: 'kSubSurface',
  782: 'kSmoothTangentSrf',
  783: 'kRenderPass',
  784: 'kRenderPassSet',
  785: 'kRenderLayer',
  786: 'kRenderLayerManager',
  787: 'kPassContributionMap',
  788: 'kPrecompExport',
  789: 'kRenderTarget',
  790: 'kRenderedImageSource',
  791: 'kImageSource',
  792: 'kPolyFlipEdge',
  793: 'kPolyExtrudeEdge',
  794: 'kAnimBlend',
  795: 'kAnimBlendInOut',
  796: 'kPolyAppendVertex',
  797: 'kUvChooser',
  798: 'kSubdivCompId',
  799: 'kVolumeAxis',
  800: 'kDeleteUVSet',
  801: 'kSubdHierBlind',
  802: 'kSubdBlindData',
  803: 'kCharacterMap',
  804: 'kLayeredTexture',
  805: 'kSubdivCollapse',
  806: 'kParticleSamplerInfo',
  807: 'kCopyUVSet',
  808: 'kCreateUVSet',
  809: 'kClip',
  810: 'kPolySplitVert',
  811: 'kSubdivData',
  812: 'kSubdivGeom',
  813: 'kUInt64ArrayData',
  814: 'kInt64ArrayData',
  815: 'kPolySplitEdge',
  816: 'kSubdivReverseFaces',
  817: 'kMeshMapComponent',
  818: 'kSectionManip',
  819: 'kXsectionSubdivEdit',
  820: 'kSubdivToNurbs',
  821: 'kEditCurve',
  822: 'kEditCurveManip',
  823: 'kCrossSectionManager',
  824: 'kCreateSectionManip',
  825: 'kCrossSectionEditManip',
  826: 'kDropOffFunction',
  827: 'kSubdBoolean',
  828: 'kSubdModifyEdge',
  829: 'kModifyEdgeCrvManip',
  830: 'kModifyEdgeManip',
  831: 'kScalePointManip',
  832: 'kTransformBoxManip',
  833: 'kSymmetryLocator',
  834: 'kSymmetryMapVector',
  835: 'kSymmetryMapCurve',
  836: 'kCurveFromSubdivEdge',
  837: 'kCreateBPManip',
  838: 'kModifyEdgeBaseManip',
  839: 'kSubdExtrudeFace',
  840: 'kSubdivSurfaceVarGroup',
  841: 'kSfRevolveManip',
  842: 'kCurveFromSubdivFace',
  843: 'kUnused1',
  844: 'kUnused2',
  845: 'kUnused3',
  846: 'kUnused4',
  847: 'kUnused5',
  848: 'kUnused6',
  849: 'kPolyTransfer',
  850: 'kPolyAverageVertex',
  851: 'kPolyAutoProj',
  852: 'kPolyLayoutUV',
  853: 'kPolyMapSewMove',
  854: 'kSubdModifier',
  855: 'kSubdMoveVertex',
  856: 'kSubdMoveEdge',
  857: 'kSubdMoveFace',
  858: 'kSubdDelFace',
  859: 'kSnapshotShape',
  860: 'kSubdivMapComponent',
  861: 'kJiggleDeformer',
  862: 'kGlobalCacheControls',
  863: 'kDiskCache',
  864: 'kSubdCloseBorder',
  865: 'kSubdMergeVert',
  866: 'kBoxData',
  867: 'kBox',
  868: 'kRenderBox',
  869: 'kSubdSplitFace',
  870: 'kVolumeFog',
  871: 'kSubdTweakUV',
  872: 'kSubdMapCut',
  873: 'kSubdLayoutUV',
  874: 'kSubdMapSewMove',
  875: 'kOcean',
  876: 'kVolumeNoise',
  877: 'kSubdAutoProj',
  878: 'kSubdSubdivideFace',
  879: 'kNoise',
  880: 'kAttribute4Double',
  881: 'kData4Double',
  882: 'kSubdPlanProj',
  883: 'kSubdTweak',
  884: 'kSubdProjectionManip',
  885: 'kSubdMappingManip',
  886: 'kHardwareReflectionMap',
  887: 'kPolyNormalizeUV',
  888: 'kPolyFlipUV',
  889: 'kHwShaderNode',
  890: 'kPluginHardwareShader',
  891: 'kPluginHwShaderNode',
  892: 'kSubdAddTopology',
  893: 'kSubdCleanTopology',
  894: 'kImplicitCone',
  895: 'kImplicitSphere',
  896: 'kRampShader',
  897: 'kVolumeLight',
  898: 'kOceanShader',
  899: 'kBevelPlus',
  900: 'kStyleCurve',
  901: 'kPolyCut',
  902: 'kPolyPoke',
  903: 'kPolyWedgeFace',
  904: 'kPolyCutManipContainer',
  905: 'kPolyCutManip',
  906: 'kPolyMirrorManipContainer',
  907: 'kPolyPokeManip',
  908: 'kFluidTexture3D',
  909: 'kFluidTexture2D',
  910: 'kPolyMergeUV',
  911: 'kPolyStraightenUVBorder',
  912: 'kAlignManip',
  913: 'kPluginTransformNode',
  914: 'kFluid',
  915: 'kFluidGeom',
  916: 'kFluidData',
  917: 'kSmear',
  918: 'kStringShadingSwitch',
  919: 'kStudioClearCoat',
  920: 'kFluidEmitter',
  921: 'kHeightField',
  922: 'kGeoConnector',
  923: 'kSnapshotPath',
  924: 'kPluginObjectSet',
  925: 'kQuadShadingSwitch',
  926: 'kPolyExtrudeVertex',
  927: 'kPairBlend',
  928: 'kTextManip',
  929: 'kViewManip',
  930: 'kXformManip',
  931: 'kMute',
  932: 'kConstraint',
  933: 'kTrimWithBoundaries',
  934: 'kCurveFromMeshCoM',
  935: 'kFollicle',
  936: 'kHairSystem',
  937: 'kRemapValue',
  938: 'kRemapColor',
  939: 'kRemapHsv',
  940: 'kHairConstraint',
  941: 'kTimeFunction',
  942: 'kMentalRayTexture',
  943: 'kObjectBinFilter',
  944: 'kPolySmoothProxy',
  945: 'kPfxGeometry',
  946: 'kPfxHair',
  947: 'kHairTubeShader',
  948: 'kPsdFileTexture',
  949: 'kKeyframeDelta',
  950: 'kKeyframeDeltaMove',
  951: 'kKeyframeDeltaScale',
  952: 'kKeyframeDeltaAddRemove',
  953: 'kKeyframeDeltaBlockAddRemove',
  954: 'kKeyframeDeltaInfType',
  955: 'kKeyframeDeltaTangent',
  956: 'kKeyframeDeltaWeighted',
  957: 'kKeyframeDeltaBreakdown',
  958: 'kPolyMirror',
  959: 'kPolyCreaseEdge',
  960: 'kPolyPinUV',
  961: 'kHikEffector',
  962: 'kHikIKEffector',
  963: 'kHikFKJoint',
  964: 'kHikSolver',
  965: 'kHikHandle',
  966: 'kProxyManager',
  967: 'kPolyAutoProjManip',
  968: 'kPolyPrism',
  969: 'kPolyPyramid',
  970: 'kPolySplitRing',
  971: 'kPfxToon',
  972: 'kToonLineAttributes',
  973: 'kPolyDuplicateEdge',
  974: 'kFacade',
  975: 'kMaterialFacade',
  976: 'kEnvFacade',
  977: 'kAISEnvFacade',
  978: 'kLineModifier',
  979: 'kPolyArrow',
  980: 'kPolyPrimitiveMisc',
  981: 'kPolyPlatonicSolid',
  982: 'kPolyPipe',
  983: 'kHikFloorContactMarker',
  984: 'kHikGroundPlane',
  985: 'kPolyComponentData',
  986: 'kPolyHelix',
  987: 'kCacheFile',
  988: 'kHistorySwitch',
  989: 'kClosestPointOnMesh',
  990: 'kUVPin',
  991: 'kProximityPin',
  992: 'kTransferAttributes',
  993: 'kDynamicConstraint',
  994: 'kNComponent',
  995: 'kPolyBridgeEdge',
  996: 'kCacheableNode',
  997: 'kNucleus',
  998: 'kNBase',
  999: 'kCacheBase',
  1000: 'kCacheBlend',
  1001: 'kCacheTrack',
  1002: 'kKeyframeRegionManip',
  1003: 'kCurveNormalizerAngle',
  1004: 'kCurveNormalizerLinear',
  1005: 'kHyperLayoutDG',
  1006: 'kPluginImagePlaneNode',
  1007: 'kNCloth',
  1008: 'kNParticle',
  1009: 'kNRigid',
  1010: 'kPluginParticleAttributeMapperNode',
  1011: 'kCameraSet',
  1012: 'kPluginCameraSet',
  1013: 'kContainer',
  1014: 'kFloatVectorArrayData',
  1015: 'kNObjectData',
  1016: 'kNObject',
  1017: 'kPluginConstraintNode',
  1018: 'kAsset',
  1019: 'kPolyEdgeToCurve',
  1020: 'kAnimLayer',
  1021: 'kBlendNodeBase',
  1022: 'kBlendNodeBoolean',
  1023: 'kBlendNodeDouble',
  1024: 'kBlendNodeDoubleAngle',
  1025: 'kBlendNodeDoubleLinear',
  1026: 'kBlendNodeEnum',
  1027: 'kBlendNodeFloat',
  1028: 'kBlendNodeFloatAngle',
  1029: 'kBlendNodeFloatLinear',
  1030: 'kBlendNodeInt16',
  1031: 'kBlendNodeInt32',
  1032: 'kBlendNodeAdditiveScale',
  1033: 'kBlendNodeAdditiveRotation',
  1034: 'kPluginManipulatorNode',
  1035: 'kNIdData',
  1036: 'kNId',
  1037: 'kFloatArrayData',
  1038: 'kMembrane',
  1039: 'kMergeVertsToolManip',
  1040: 'kUint64SingleIndexedComponent',
  1041: 'kPolyToolFeedbackManip',
  1042: 'kPolySelectEditFeedbackManip',
  1043: 'kWriteToFrameBuffer',
  1044: 'kWriteToColorBuffer',
  1045: 'kWriteToVectorBuffer',
  1046: 'kWriteToDepthBuffer',
  1047: 'kWriteToLabelBuffer',
  1048: 'kStereoCameraMaster',
  1049: 'kSequenceManager',
  1050: 'kSequencer',
  1051: 'kShot',
  1052: 'kBlendNodeTime',
  1053: 'kCreateBezierManip',
  1054: 'kBezierCurve',
  1055: 'kBezierCurveData',
  1056: 'kNurbsCurveToBezier',
  1057: 'kBezierCurveToNurbs',
  1058: 'kPolySpinEdge',
  1059: 'kPolyHoleFace',
  1060: 'kPointOnPolyConstraint',
  1061: 'kPolyConnectComponents',
  1062: 'kSkinBinding',
  1063: 'kVolumeBindManip',
  1064: 'kVertexWeightSet',
  1065: 'kNearestPointOnCurve',
  1066: 'kColorProfile',
  1067: 'kAdskMaterial',
  1068: 'kContainerBase',
  1069: 'kDagContainer',
  1070: 'kPolyUVRectangle',
  1071: 'kHardwareRenderingGlobals',
  1072: 'kPolyProjectCurve',
  1073: 'kRenderingList',
  1074: 'kPolyExtrudeManip',
  1075: 'kPolyExtrudeManipContainer',
  1076: 'kThreadedDevice',
  1077: 'kClientDevice',
  1078: 'kPluginClientDevice',
  1079: 'kPluginThreadedDevice',
  1080: 'kTimeWarp',
  1081: 'kAssembly',
  1082: 'kClipGhostShape',
  1083: 'kClipToGhostData',
  1084: 'kMandelbrot',
  1085: 'kMandelbrot3D',
  1086: 'kGreasePlane',
  1087: 'kGreasePlaneRenderShape',
  1088: 'kGreasePencilSequence',
  1089: 'kEditMetadata',
  1090: 'kCreaseSet',
  1091: 'kPolyEditEdgeFlow',
  1092: 'kFosterParent',
  1093: 'kSnapUVManip2D',
  1094: 'kToolContext',
  1095: 'kNLE',
  1096: 'kShrinkWrapFilter',
  1097: 'kEditsManager',
  1098: 'kPolyBevel2',
  1099: 'kPolyCBoolOp',
  1100: 'kGeomBind',
  1101: 'kColorMgtGlobals',
  1102: 'kPolyBevel3',
  1103: 'kTimeEditorClipBase',
  1104: 'kTimeEditorClipEvaluator',
  1105: 'kTimeEditorClip',
  1106: 'kTimeEditor',
  1107: 'kTimeEditorTracks',
  1108: 'kTimeEditorInterpolator',
  1109: 'kTimeEditorAnimSource',
  1110: 'kCaddyManipBase',
  1111: 'kPolyCaddyManip',
  1112: 'kPolyModifierManipContainer',
  1113: 'kPolyRemesh',
  1114: 'kPolyContourProj',
  1115: 'kContourProjectionManip',
  1116: 'kNodeGraphEditorInfo',
  1117: 'kNodeGraphEditorBookmarks',
  1118: 'kNodeGraphEditorBookmarkInfo',
  1119: 'kPluginSkinCluster',
  1120: 'kPluginGeometryFilter',
  1121: 'kPluginBlendShape',
  1122: 'kPolyPassThru',
  1123: 'kTrackInfoManager',
  1124: 'kPolyClean',
  1125: 'kShapeEditorManager',
  1126: 'kOceanDeformer',
  1127: 'kPoseInterpolatorManager',
  1128: 'kControllerTag',
  1129: 'kReForm',
  1130: 'kCustomEvaluatorClusterNode',
  1131: 'kPolyCircularize',
  1132: 'kArubaTesselate',
  1133: 'kReorderUVSet',
  1134: 'kUfeProxyTransform',
  1135: 'kDecomposeMatrix',
  1136: 'kComposeMatrix',
  1137: 'kBlendMatrix',
  1138: 'kPickMatrix',
  1139: 'kAimMatrix',
  1140: 'kPrimitiveFalloff',
  1141: 'kBlendFalloff',
  1142: 'kUniformFalloff',
  1143: 'kTransferFalloff',
  1144: 'kComponentFalloff',
  1145: 'kWeightFunctionData',
  1146: 'kFalloffEval',
  1147: 'kComponentMatch',
  1148: 'kLast'},
 {'AISEnvFacade': 'kAISEnvFacade',
  'THarrayMapper': 'kPluginParticleAttributeMapperNode',
  'THassembly': 'kAssembly',
  'THblendShape': 'kPluginBlendShape',
  'THcameraSet': 'kPluginCameraSet',
  'THclientDevice': 'kPluginClientDevice',
  'THconstraint': 'kPluginConstraintNode',
  'THcustomTransform': 'kPluginTransformNode',
  'THdeformer': 'kPluginDeformerNode',
  'THdependNode': 'kPluginDependNode',
  'THdynEmitter': 'kPluginEmitterNode',
  'THdynField': 'kPluginFieldNode',
  'THdynSpring': 'kPluginSpringNode',
  'THfluidEmitter': 'kPluginEmitterNode',
  'THgeometryFilter': 'kPluginGeometryFilter',
  'THhardwareShader': 'kPluginHardwareShader',
  'THhwShader': 'kPluginHwShaderNode',
  'THikSolverNode': 'kPluginIkSolver',
  'THimagePlane': 'kPluginImagePlaneNode',
  'THlocatorShape': 'kPluginLocatorNode',
  'THmanip': 'kPluginManipulatorNode',
  'THmanipContainer': 'kPluginManipContainer',
  'THmotionPath': 'kPluginMotionPathNode',
  'THobjectSet': 'kPluginObjectSet',
  'THskinCluster': 'kPluginSkinCluster',
  'THsurfaceShape': 'kPluginShape',
  'THthreadedDevice': 'kPluginThreadedDevice',
  'TadskAssetInstanceNode_TdependNode': 'kDependencyNode',
  'TadskAssetInstanceNode_TdnTx2D': 'kTexture2d',
  'TadskAssetInstanceNode_TlightShape': 'kLight',
  'aboutToSetValueTestNode': 'kDependencyNode',
  'abstractBaseCreate': 'kCreate',
  'abstractBaseNurbsConversion': 'kCreate',
  'addDoubleLinear': 'kAddDoubleLinear',
  'addMatrix': 'kMatrixAdd',
  'adskMaterial': 'kAdskMaterial',
  'aimConstraint': 'kAimConstraint',
  'aimMatrix': 'kAimMatrix',
  'airField': 'kAir',
  'alignCurve': 'kAlignCurve',
  'alignSurface': 'kAlignSurface',
  'ambientLight': 'kAmbientLight',
  'angleBetween': 'kAngleBetween',
  'angleDimension': 'kAngle',
  'animBlend': 'kAnimBlend',
  'animBlendInOut': 'kAnimBlendInOut',
  'animBlendNodeAdditive': 'kBlendNodeDouble',
  'animBlendNodeAdditiveDA': 'kBlendNodeDoubleAngle',
  'animBlendNodeAdditiveDL': 'kBlendNodeDoubleLinear',
  'animBlendNodeAdditiveF': 'kBlendNodeFloat',
  'animBlendNodeAdditiveFA': 'kBlendNodeFloatAngle',
  'animBlendNodeAdditiveFL': 'kBlendNodeFloatLinear',
  'animBlendNodeAdditiveI16': 'kBlendNodeInt16',
  'animBlendNodeAdditiveI32': 'kBlendNodeInt32',
  'animBlendNodeAdditiveRotation': 'kBlendNodeAdditiveRotation',
  'animBlendNodeAdditiveScale': 'kBlendNodeAdditiveScale',
  'animBlendNodeBase': 'kDependencyNode',
  'animBlendNodeBoolean': 'kBlendNodeBoolean',
  'animBlendNodeEnum': 'kBlendNodeEnum',
  'animBlendNodeTime': 'kBlendNodeTime',
  'animClip': 'kClip',
  'animCurve': 'kAnimCurve',
  'animCurveTA': 'kAnimCurveTimeToAngular',
  'animCurveTL': 'kAnimCurveTimeToDistance',
  'animCurveTT': 'kAnimCurveTimeToTime',
  'animCurveTU': 'kAnimCurveTimeToUnitless',
  'animCurveUA': 'kAnimCurveUnitlessToAngular',
  'animCurveUL': 'kAnimCurveUnitlessToDistance',
  'animCurveUT': 'kAnimCurveUnitlessToTime',
  'animCurveUU': 'kAnimCurveUnitlessToUnitless',
  'animLayer': 'kAnimLayer',
  'anisotropic': 'kAnisotropy',
  'annotationShape': 'kAnnotation',
  'arcLengthDimension': 'kArcLength',
  'areaLight': 'kAreaLight',
  'arrayMapper': 'kArrayMapper',
  'arubaTessellate': 'kArubaTesselate',
  'assembly': 'kAssembly',
  'assemblyDefinition': 'kAssembly',
  'assemblyReference': 'kAssembly',
  'attachCurve': 'kAttachCurve',
  'attachSurface': 'kAttachSurface',
  'attrHierarchyTest': 'kDependencyNode',
  'audio': 'kAudio',
  'avgCurves': 'kAvgCurves',
  'avgNurbsSurfacePoints': 'kAvgNurbsSurfacePoints',
  'avgSurfacePoints': 'kAvgSurfacePoints',
  'bakeSet': 'kSet',
  'baseGeometryVarGroup': 'kTransform',
  'baseLattice': 'kBaseLattice',
  'baseShadingSwitch': 'kDependencyNode',
  'bevel': 'kBevel',
  'bevelPlus': 'kBevelPlus',
  'bezierCurve': 'kNurbsCurve',
  'bezierCurveToNurbs': 'kBezierCurveToNurbs',
  'birailSrf': 'kBirailSrf',
  'blend': 'kBlend',
  'blendColorSets': 'kBlendColorSet',
  'blendColors': 'kBlendColors',
  'blendDevice': 'kBlendDevice',
  'blendFalloff': 'kBlendFalloff',
  'blendMatrix': 'kBlendMatrix',
  'blendShape': 'kBlendShape',
  'blendTwoAttr': 'kBlendTwoAttr',
  'blendWeighted': 'kBlendWeighted',
  'blindDataTemplate': 'kBlindDataTemplate',
  'blinn': 'kBlinn',
  'boneLattice': 'kBulgeLattice',
  'boolean': 'kNurbsBoolean',
  'boundary': 'kBoundary',
  'boundaryBase': 'kCreate',
  'brownian': 'kBrownian',
  'brush': 'kBrush',
  'bulge': 'kBulge',
  'bump2d': 'kBump',
  'bump3d': 'kBump3d',
  'cacheBase': 'kCacheBase',
  'cacheBlend': 'kCacheTrack',
  'cacheFile': 'kCacheFile',
  'camera': 'kCamera',
  'cameraSet': 'kCameraSet',
  'cameraView': 'kCameraView',
  'character': 'kCharacter',
  'characterMap': 'kCharacterMap',
  'characterOffset': 'kCharacterOffset',
  'checker': 'kChecker',
  'choice': 'kChoice',
  'chooser': 'kChooser',
  'clamp': 'kClampColor',
  'clientDevice': 'kClientDevice',
  'clipGhostShape': 'kClipGhostShape',
  'clipLibrary': 'kClipLibrary',
  'clipScheduler': 'kClipScheduler',
  'clipToGhostData': 'kClipToGhostData',
  'closeCurve': 'kCloseCurve',
  'closeSurface': 'kCloseSurface',
  'closestPointOnMesh': 'kClosestPointOnMesh',
  'closestPointOnSurface': 'kClosestPointOnSurface',
  'cloth': 'kCloth',
  'cloud': 'kCloud',
  'cluster': 'kClusterFilter',
  'clusterFlexorShape': 'kClusterFlexor',
  'clusterHandle': 'kCluster',
  'collisionModel': 'kCollision',
  'colorManagementGlobals': 'kColorMgtGlobals',
  'colorProfile': 'kColorProfile',
  'combinationShape': 'kCombinationShape',
  'compactPlugArrayTest': 'kDependencyNode',
  'componentFalloff': 'kComponentFalloff',
  'componentMatch': 'kComponentMatch',
  'composeMatrix': 'kComposeMatrix',
  'condition': 'kCondition',
  'constraint': 'kConstraint',
  'container': 'kContainer',
  'containerBase': 'kContainerBase',
  'contrast': 'kContrast',
  'controlPoint': 'kShape',
  'controller': 'kControllerTag',
  'copyColorSet': 'kCopyColorSet',
  'copyUVSet': 'kCopyUVSet',
  'crater': 'kCrater',
  'creaseSet': 'kCreaseSet',
  'createColorSet': 'kCreateColorSet',
  'createUVSet': 'kCreateUVSet',
  'curveFromMesh': 'kDependencyNode',
  'curveFromMeshCoM': 'kCurveFromMeshCoM',
  'curveFromMeshEdge': 'kCurveFromMeshEdge',
  'curveFromSubdiv': 'kCreate',
  'curveFromSubdivEdge': 'kCurveFromSubdivEdge',
  'curveFromSubdivFace': 'kCurveFromSubdivFace',
  'curveFromSurface': 'kCurveFromSurface',
  'curveFromSurfaceBnd': 'kCurveFromSurfaceBnd',
  'curveFromSurfaceCoS': 'kCurveFromSurfaceCoS',
  'curveFromSurfaceIso': 'kCurveFromSurfaceIso',
  'curveInfo': 'kCurveInfo',
  'curveIntersect': 'kCurveCurveIntersect',
  'curveNormalizer': 'kDependencyNode',
  'curveNormalizerAngle': 'kCurveNormalizerAngle',
  'curveNormalizerLinear': 'kCurveNormalizerLinear',
  'curveRange': 'kCreate',
  'curveShape': 'kCurve',
  'curveVarGroup': 'kCurveVarGroup',
  'dagContainer': 'kDagContainer',
  'dagNode': 'kDagNode',
  'dagPose': 'kDagPose',
  'dataBlockTest': 'kDependencyNode',
  'decomposeMatrix': 'kDecomposeMatrix',
  'defaultLightList': 'kDefaultLightList',
  'defaultRenderUtilityList': 'kRenderUtilityList',
  'defaultRenderingList': 'kRenderingList',
  'defaultShaderList': 'kShaderList',
  'defaultTextureList': 'kTextureList',
  'deformBend': 'kDeformBend',
  'deformFlare': 'kDeformFlare',
  'deformFunc': 'kDeformFunc',
  'deformSine': 'kDeformSine',
  'deformSquash': 'kDeformSquash',
  'deformTwist': 'kDeformTwist',
  'deformWave': 'kDeformWave',
  'deformableShape': 'kShape',
  'deleteColorSet': 'kDeleteColorSet',
  'deleteComponent': 'kDeleteComponent',
  'deleteUVSet': 'kDeleteUVSet',
  'deltaMush': 'kDeltaMush',
  'dependNode': 'kDependencyNode',
  'detachCurve': 'kDetachCurve',
  'detachSurface': 'kDetachSurface',
  'dimensionShape': 'kDimension',
  'directedDisc': 'kDirectedDisc',
  'directionalLight': 'kDirectionalLight',
  'diskCache': 'kDiskCache',
  'displacementShader': 'kDisplacementShader',
  'displayLayer': 'kDisplayLayer',
  'displayLayerManager': 'kDisplayLayerManager',
  'distanceBetween': 'kDistanceBetween',
  'distanceDimShape': 'kDistance',
  'dof': 'kDOF',
  'doubleShadingSwitch': 'kDoubleShadingSwitch',
  'dpBirailSrf': 'kDPbirailSrf',
  'dragField': 'kDrag',
  'dropoffLocator': 'kDropoffLocator',
  'dynBase': 'kDynBase',
  'dynController': 'kDynamicsController',
  'dynGlobals': 'kDynGlobals',
  'dynHolder': 'kDummy',
  'dynamicConstraint': 'kDynamicConstraint',
  'editMetadata': 'kEditMetadata',
  'editsManager': 'kEditsManager',
  'entity': 'kContainerBase',
  'envBall': 'kEnvBall',
  'envChrome': 'kEnvChrome',
  'envCube': 'kEnvCube',
  'envFacade': 'kEnvFacade',
  'envFog': 'kEnvFogMaterial',
  'envSky': 'kEnvSky',
  'envSphere': 'kEnvSphere',
  'environmentFog': 'kEnvFogShape',
  'explodeNurbsShell': 'kExplodeNurbsShell',
  'expression': 'kExpression',
  'extendCurve': 'kExtendCurve',
  'extendSurface': 'kExtendSurface',
  'extrude': 'kExtrude',
  'facade': 'kFacade',
  'falloffEval': 'kFalloffEval',
  'ffBlendSrf': 'kFFblendSrf',
  'ffBlendSrfObsolete': 'kFFblendSrf',
  'ffFilletSrf': 'kFFfilletSrf',
  'ffd': 'kFFD',
  'field': 'kField',
  'file': 'kFileTexture',
  'filletCurve': 'kFilletCurve',
  'fitBspline': 'kFitBspline',
  'flexorShape': 'kFlexor',
  'flow': 'kFlow',
  'fluidEmitter': 'kFluidEmitter',
  'fluidShape': 'kFluid',
  'fluidTexture2D': 'kFluidTexture2D',
  'fluidTexture3D': 'kFluidTexture3D',
  'follicle': 'kFollicle',
  'fosterParent': 'kFosterParent',
  'fourByFourMatrix': 'kFourByFourMatrix',
  'fractal': 'kFractal',
  'frameCache': 'kTime',
  'gammaCorrect': 'kGammaCorrect',
  'geoConnectable': 'kGeoConnectable',
  'geoConnector': 'kGeoConnector',
  'geomBind': 'kGeomBind',
  'geometryConstraint': 'kGeometryConstraint',
  'geometryFilter': 'kGeometryFilt',
  'geometryShape': 'kShape',
  'geometryVarGroup': 'kAnyGeometryVarGroup',
  'globalCacheControl': 'kGlobalCacheControls',
  'globalStitch': 'kGlobalStitch',
  'granite': 'kGranite',
  'gravityField': 'kGravity',
  'greasePencilSequence': 'kGreasePencilSequence',
  'greasePlane': 'kGreasePlane',
  'greasePlaneRenderShape': 'kGreasePlaneRenderShape',
  'grid': 'kGrid',
  'groundPlane': 'kGroundPlane',
  'groupId': 'kGroupId',
  'groupParts': 'kGroupParts',
  'guide': 'kGuide',
  'hairConstraint': 'kHairConstraint',
  'hairSystem': 'kHairSystem',
  'hairTubeShader': 'kHairTubeShader',
  'hardenPoint': 'kHardenPointCurve',
  'hardwareRenderGlobals': 'kHardwareRenderGlobals',
  'hardwareRenderingGlobals': 'kHardwareRenderingGlobals',
  'heightField': 'kHeightField',
  'hierarchyTestNode1': 'kDependencyNode',
  'hierarchyTestNode2': 'kDependencyNode',
  'hierarchyTestNode3': 'kDependencyNode',
  'hikEffector': 'kHikEffector',
  'hikFKJoint': 'kHikFKJoint',
  'hikFloorContactMarker': 'kHikFloorContactMarker',
  'hikGroundPlane': 'kHikGroundPlane',
  'hikHandle': 'kHikHandle',
  'hikIKEffector': 'kHikIKEffector',
  'hikSolver': 'kHikSolver',
  'historySwitch': 'kHistorySwitch',
  'holdMatrix': 'kMatrixHold',
  'hsvToRgb': 'kHsvToRgb',
  'hwReflectionMap': 'kHardwareReflectionMap',
  'hwRenderGlobals': 'kHardwareRenderGlobals',
  'hwShader': 'kHwShaderNode',
  'hyperGraphInfo': 'kHyperGraphInfo',
  'hyperLayout': 'kHyperLayout',
  'hyperView': 'kHyperView',
  'ikEffector': 'kIkEffector',
  'ikHandle': 'kIkHandle',
  'ikMCsolver': 'kMCsolver',
  'ikPASolver': 'kPASolver',
  'ikRPsolver': 'kRPsolver',
  'ikSCsolver': 'kSCsolver',
  'ikSolver': 'kIkSolver',
  'ikSplineSolver': 'kSplineSolver',
  'ikSystem': 'kIkSystem',
  'imagePlane': 'kImagePlane',
  'imageSource': 'kImageSource',
  'implicitBox': 'kBox',
  'implicitCone': 'kImplicitCone',
  'implicitSphere': 'kImplicitSphere',
  'insertKnotCurve': 'kInsertKnotCrv',
  'insertKnotSurface': 'kInsertKnotSrf',
  'instancer': 'kInstancer',
  'intersectSurface': 'kIntersectSurface',
  'jiggle': 'kJiggleDeformer',
  'joint': 'kJoint',
  'jointCluster': 'kJointCluster',
  'jointFfd': 'kFfdDualBase',
  'jointLattice': 'kBendLattice',
  'keyingGroup': 'kKeyingGroup',
  'lambert': 'kLambert',
  'lattice': 'kLattice',
  'layeredShader': 'kLayeredShader',
  'layeredTexture': 'kLayeredTexture',
  'leastSquaresModifier': 'kLeastSquares',
  'leather': 'kLeather',
  'light': 'kLight',
  'lightFog': 'kLightFogMaterial',
  'lightInfo': 'kLightInfo',
  'lightLinker': 'kLightLink',
  'lightList': 'kLightList',
  'lineModifier': 'kLineModifier',
  'locator': 'kLocator',
  'lodGroup': 'kLodGroup',
  'lodThresholds': 'kLodThresholds',
  'loft': 'kSkin',
  'lookAt': 'kLookAt',
  'luminance': 'kLuminance',
  'makeCircularArc': 'kCreate',
  'makeGroup': 'kMakeGroup',
  'makeIllustratorCurves': 'kIllustratorCurve',
  'makeNurbCircle': 'kCircle',
  'makeNurbCone': 'kCone',
  'makeNurbCube': 'kNurbsCube',
  'makeNurbCylinder': 'kCylinder',
  'makeNurbPlane': 'kNurbsPlane',
  'makeNurbSphere': 'kSphere',
  'makeNurbTorus': 'kTorus',
  'makeNurbsSquare': 'kNurbsSquare',
  'makeTextCurves': 'kTextCurves',
  'makeThreePointCircularArc': 'kNurbsCircular3PtArc',
  'makeTwoPointCircularArc': 'kNurbsCircular2PtArc',
  'mandelbrot': 'kMandelbrot',
  'mandelbrot3D': 'kMandelbrot3D',
  'marble': 'kMarble',
  'materialFacade': 'kMaterialFacade',
  'materialInfo': 'kMaterialInfo',
  'materialTemplate': 'kMaterialTemplate',
  'membrane': 'kMembrane',
  'mesh': 'kMesh',
  'meshVarGroup': 'kMeshVarGroup',
  'morph': 'kMorph',
  'motionPath': 'kMotionPath',
  'motionTrail': 'kSnapshotPath',
  'motionTrailShape': 'kSnapshot',
  'mountain': 'kMountain',
  'moveVertexManip': 'kMoveVertexManip',
  'movie': 'kFileTexture',
  'mpBirailSrf': 'kMPbirailSrf',
  'multDoubleLinear': 'kMultDoubleLinear',
  'multMatrix': 'kMatrixMult',
  'multilisterLight': 'kMultilisterLight',
  'multiplyDivide': 'kMultiplyDivide',
  'mute': 'kMute',
  'nBase': 'kNBase',
  'nCloth': 'kNCloth',
  'nComponent': 'kNComponent',
  'nParticle': 'kNParticle',
  'nRigid': 'kNRigid',
  'nearestPointOnCurve': 'kNearestPointOnCurve',
  'network': 'kAffect',
  'newtonField': 'kNewton',
  'node': 'kDependencyNode',
  'nodeGraphEditorBookmarkInfo': 'kNodeGraphEditorBookmarkInfo',
  'nodeGraphEditorBookmarks': 'kNodeGraphEditorBookmarks',
  'nodeGraphEditorInfo': 'kNodeGraphEditorInfo',
  'noise': 'kNoise',
  'nonAmbientLightShapeNode': 'kNonAmbientLight',
  'nonExtendedLightShapeNode': 'kNonExtendedLight',
  'nonLinear': 'kNonLinear',
  'normalConstraint': 'kNormalConstraint',
  'nucleus': 'kNucleus',
  'nurbsCurve': 'kNurbsCurve',
  'nurbsCurveToBezier': 'kNurbsCurveToBezier',
  'nurbsDimShape': 'kDimension',
  'nurbsSurface': 'kNurbsSurface',
  'nurbsTessellate': 'kNurbsTesselate',
  'nurbsToSubdiv': 'kNurbsToSubdiv',
  'nurbsToSubdivProc': 'kNurbsToSubdiv',
  'objectAttrFilter': 'kObjectAttrFilter',
  'objectBinFilter': 'kObjectBinFilter',
  'objectFilter': 'kObjectFilter',
  'objectMultiFilter': 'kObjectMultiFilter',
  'objectNameFilter': 'kObjectNameFilter',
  'objectRenderFilter': 'kObjectRenderFilter',
  'objectScriptFilter': 'kObjectScriptFilter',
  'objectSet': 'kSet',
  'objectTypeFilter': 'kObjectTypeFilter',
  'ocean': 'kOcean',
  'oceanShader': 'kOceanShader',
  'offsetCos': 'kOffsetCos',
  'offsetCurve': 'kOffsetCurve',
  'offsetSurface': 'kOffsetSurface',
  'oldBlindDataBase': 'kDependencyNode',
  'oldGeometryConstraint': 'kOldGeometryConstraint',
  'oldNormalConstraint': 'kNormalConstraint',
  'oldTangentConstraint': 'kTangentConstraint',
  'opticalFX': 'kOpticalFX',
  'orientConstraint': 'kOrientConstraint',
  'orientationMarker': 'kOrientationMarker',
  'orthoGrid': 'kOrthoGrid',
  'pairBlend': 'kPairBlend',
  'paramDimension': 'kParamDimension',
  'parentConstraint': 'kParentConstraint',
  'parentTessellate': 'kCreate',
  'particle': 'kParticle',
  'particleAgeMapper': 'kParticleAgeMapper',
  'particleCloud': 'kParticleCloud',
  'particleColorMapper': 'kParticleColorMapper',
  'particleIncandMapper': 'kParticleIncandecenceMapper',
  'particleSamplerInfo': 'kParticleSamplerInfo',
  'particleTranspMapper': 'kParticleTransparencyMapper',
  'partition': 'kPartition',
  'passContributionMap': 'kPassContributionMap',
  'passMatrix': 'kMatrixPass',
  'pfxGeometry': 'kPfxGeometry',
  'pfxHair': 'kPfxHair',
  'pfxToon': 'kPfxToon',
  'phong': 'kPhong',
  'phongE': 'kPhongExplorer',
  'pickMatrix': 'kPickMatrix',
  'place2dTexture': 'kPlace2dTexture',
  'place3dTexture': 'kPlace3dTexture',
  'planarTrimSurface': 'kPlanarTrimSrf',
  'plane': 'kPlane',
  'plusMinusAverage': 'kPlusMinusAverage',
  'pointConstraint': 'kPointConstraint',
  'pointEmitter': 'kEmitter',
  'pointLight': 'kPointLight',
  'pointMatrixMult': 'kPointMatrixMult',
  'pointOnCurveInfo': 'kPointOnCurveInfo',
  'pointOnPolyConstraint': 'kPointOnPolyConstraint',
  'pointOnSurfaceInfo': 'kPointOnSurfaceInfo',
  'poleVectorConstraint': 'kPoleVectorConstraint',
  'polyAppend': 'kPolyAppend',
  'polyAppendVertex': 'kPolyAppendVertex',
  'polyAutoProj': 'kPolyAutoProj',
  'polyAverageVertex': 'kPolyAverageVertex',
  'polyBase': 'kDependencyNode',
  'polyBevel': 'kPolyBevel',
  'polyBevel2': 'kPolyBevel2',
  'polyBevel3': 'kPolyBevel3',
  'polyBlindData': 'kPolyBlindData',
  'polyBoolOp': 'kPolyBoolOp',
  'polyBridgeEdge': 'kPolyBridgeEdge',
  'polyCBoolOp': 'kPolyCBoolOp',
  'polyChipOff': 'kPolyChipOff',
  'polyCircularize': 'kPolyCircularize',
  'polyClean': 'kPolyClean',
  'polyCloseBorder': 'kPolyCloseBorder',
  'polyCollapseEdge': 'kPolyCollapseEdge',
  'polyCollapseF': 'kPolyCollapseF',
  'polyColorDel': 'kPolyColorDel',
  'polyColorMod': 'kPolyColorMod',
  'polyColorPerVertex': 'kPolyColorPerVertex',
  'polyCone': 'kPolyCone',
  'polyConnectComponents': 'kPolyConnectComponents',
  'polyContourProj': 'kPolyContourProj',
  'polyCopyUV': 'kMidModifier',
  'polyCrease': 'kPolyCreaseEdge',
  'polyCreaseEdge': 'kPolyCreaseEdge',
  'polyCreateFace': 'kPolyCreateFacet',
  'polyCreator': 'kPolyCreator',
  'polyCube': 'kPolyCube',
  'polyCut': 'kPolyCut',
  'polyCylProj': 'kPolyCylProj',
  'polyCylinder': 'kPolyCylinder',
  'polyDelEdge': 'kPolyDelEdge',
  'polyDelFacet': 'kPolyDelFacet',
  'polyDelVertex': 'kPolyDelVertex',
  'polyDuplicateEdge': 'kPolyDuplicateEdge',
  'polyEdgeToCurve': 'kPolyEdgeToCurve',
  'polyEditEdgeFlow': 'kPolyEditEdgeFlow',
  'polyExtrudeEdge': 'kPolyExtrudeEdge',
  'polyExtrudeFace': 'kPolyExtrudeFacet',
  'polyExtrudeVertex': 'kPolyExtrudeVertex',
  'polyFlipEdge': 'kPolyFlipEdge',
  'polyFlipUV': 'kPolyFlipUV',
  'polyHelix': 'kPolyHelix',
  'polyHoleFace': 'kPolyHoleFace',
  'polyLayoutUV': 'kPolyLayoutUV',
  'polyMapCut': 'kPolyMapCut',
  'polyMapDel': 'kPolyMapDel',
  'polyMapSew': 'kPolyMapSew',
  'polyMapSewMove': 'kPolyMapSewMove',
  'polyMergeEdge': 'kPolyMergeEdge',
  'polyMergeFace': 'kPolyMergeFacet',
  'polyMergeUV': 'kPolyMergeUV',
  'polyMergeVert': 'kPolyMergeVert',
  'polyMirror': 'kPolyMirror',
  'polyModifier': 'kDependencyNode',
  'polyModifierUV': 'kDependencyNode',
  'polyModifierWorld': 'kDependencyNode',
  'polyMoveEdge': 'kPolyMoveEdge',
  'polyMoveFace': 'kPolyMoveFacet',
  'polyMoveFacetUV': 'kPolyMoveFacetUV',
  'polyMoveUV': 'kPolyMoveUV',
  'polyMoveVertex': 'kPolyMoveVertex',
  'polyNormal': 'kPolyNormal',
  'polyNormalPerVertex': 'kPolyNormalPerVertex',
  'polyNormalizeUV': 'kPolyNormalizeUV',
  'polyOptUvs': 'kMidModifier',
  'polyPassThru': 'kPolyPassThru',
  'polyPinUV': 'kPolyPinUV',
  'polyPipe': 'kPolyPipe',
  'polyPlanarProj': 'kPolyPlanProj',
  'polyPlane': 'kPolyMesh',
  'polyPlatonicSolid': 'kPolyPlatonicSolid',
  'polyPoke': 'kPolyPoke',
  'polyPrimitive': 'kPolyPrimitive',
  'polyPrimitiveMisc': 'kPolyPrimitiveMisc',
  'polyPrism': 'kPolyPrism',
  'polyProj': 'kPolyProj',
  'polyProjectCurve': 'kPolyProjectCurve',
  'polyPyramid': 'kPolyPyramid',
  'polyQuad': 'kPolyQuad',
  'polyReduce': 'kPolyReduce',
  'polyRemesh': 'kPolyRemesh',
  'polyRetopo': 'kReForm',
  'polySeparate': 'kPolySeparate',
  'polySewEdge': 'kPolySewEdge',
  'polySmooth': 'kPolySmooth',
  'polySmoothFace': 'kPolySmoothFacet',
  'polySmoothProxy': 'kPolySmoothProxy',
  'polySoftEdge': 'kPolySoftEdge',
  'polySphProj': 'kPolySphProj',
  'polySphere': 'kPolySphere',
  'polySpinEdge': 'kPolySpinEdge',
  'polySplit': 'kPolySplit',
  'polySplitEdge': 'kPolySplitEdge',
  'polySplitRing': 'kPolySplitRing',
  'polySplitVert': 'kPolySplitVert',
  'polyStraightenUVBorder': 'kPolyStraightenUVBorder',
  'polySubdEdge': 'kPolySubdEdge',
  'polySubdFace': 'kPolySubdFacet',
  'polyToSubdiv': 'kPolyToSubdiv',
  'polyTorus': 'kPolyTorus',
  'polyTransfer': 'kPolyTransfer',
  'polyTriangulate': 'kPolyTriangulate',
  'polyTweak': 'kPolyTweak',
  'polyTweakUV': 'kPolyTweakUV',
  'polyUVRectangle': 'kPolyUVRectangle',
  'polyUnite': 'kPolyUnite',
  'polyWedgeFace': 'kPolyWedgeFace',
  'poseInterpolatorManager': 'kPoseInterpolatorManager',
  'positionMarker': 'kPositionMarker',
  'postProcessList': 'kPostProcessList',
  'precompExport': 'kPrecompExport',
  'primitive': 'kPrimitive',
  'primitiveFalloff': 'kPrimitiveFalloff',
  'projectCurve': 'kProjectCurve',
  'projectTangent': 'kProjectTangent',
  'projection': 'kProjection',
  'proximityPin': 'kProximityPin',
  'proximityWrap': 'kProximityWrap',
  'proxyManager': 'kProxyManager',
  'psdFileTex': 'kPsdFileTexture',
  'quadShadingSwitch': 'kQuadShadingSwitch',
  'radialField': 'kRadial',
  'ramp': 'kRamp',
  'rampShader': 'kRampShader',
  'rbfSrf': 'kRBFsurface',
  'rebuildCurve': 'kRebuildCurve',
  'rebuildSurface': 'kRebuildSurface',
  'record': 'kRecord',
  'reference': 'kReference',
  'reflect': 'kReflect',
  'remapColor': 'kRemapColor',
  'remapHsv': 'kRemapHsv',
  'remapValue': 'kRemapValue',
  'renderBox': 'kRenderBox',
  'renderCone': 'kRenderCone',
  'renderGlobals': 'kRenderGlobals',
  'renderGlobalsList': 'kRenderGlobalsList',
  'renderLayer': 'kRenderLayer',
  'renderLayerManager': 'kRenderLayerManager',
  'renderLight': 'kLight',
  'renderPass': 'kRenderPass',
  'renderPassSet': 'kRenderPassSet',
  'renderQuality': 'kRenderQuality',
  'renderRect': 'kRenderRect',
  'renderSphere': 'kRenderSphere',
  'renderTarget': 'kRenderTarget',
  'renderedImageSource': 'kRenderedImageSource',
  'reorderUVSet': 'kReorderUVSet',
  'resolution': 'kResolution',
  'resultCurve': 'kResultCurve',
  'resultCurveTimeToAngular': 'kResultCurveTimeToAngular',
  'resultCurveTimeToLinear': 'kResultCurveTimeToDistance',
  'resultCurveTimeToTime': 'kResultCurveTimeToTime',
  'resultCurveTimeToUnitless': 'kResultCurveTimeToUnitless',
  'reverse': 'kReverse',
  'reverseCurve': 'kReverseCurve',
  'reverseSurface': 'kReverseSurface',
  'revolve': 'kRevolve',
  'revolvedPrimitive': 'kRevolvedPrimitive',
  'rgbToHsv': 'kRgbToHsv',
  'rigidBody': 'kRigid',
  'rigidConstraint': 'kRigidConstraint',
  'rigidSolver': 'kRigidSolver',
  'rock': 'kRock',
  'roundConstantRadius': 'kRoundConstantRadius',
  'sampler': 'kTime',
  'samplerInfo': 'kSamplerInfo',
  'scaleConstraint': 'kScaleConstraint',
  'script': 'kScript',
  'sculpt': 'kSculpt',
  'selectionListOperator': 'kSelectionListOperator',
  'sequenceManager': 'kSequenceManager',
  'sequencer': 'kSequencer',
  'setRange': 'kSetRange',
  'shaderGlow': 'kShaderGlow',
  'shadingDependNode': 'kDependencyNode',
  'shadingEngine': 'kShadingEngine',
  'shadingMap': 'kShadingMap',
  'shape': 'kShape',
  'shapeEditorManager': 'kShapeEditorManager',
  'shellTessellate': 'kNurbsTesselate',
  'shot': 'kShot',
  'shrinkWrap': 'kShrinkWrapFilter',
  'simpleTestNode': 'kDependencyNode',
  'simpleVolumeShader': 'kSimpleVolumeShader',
  'singleShadingSwitch': 'kSingleShadingSwitch',
  'sketchPlane': 'kSketchPlane',
  'skinBinding': 'kSkinBinding',
  'skinCluster': 'kSkinClusterFilter',
  'smear': 'kSmear',
  'smoothCurve': 'kSmoothCurve',
  'smoothTangentSrf': 'kSmoothTangentSrf',
  'snapshot': 'kSnapshotPath',
  'snapshotShape': 'kSnapshot',
  'snow': 'kSnow',
  'softMod': 'kSoftModFilter',
  'softModHandle': 'kSoftMod',
  'solidFractal': 'kSolidFractal',
  'solidify': 'kSolidify',
  'spBirailSrf': 'kSPbirailSrf',
  'spotLight': 'kSpotLight',
  'spring': 'kSpring',
  'squareSrf': 'kSquareSrf',
  'standardSurface': 'kStandardSurface',
  'stencil': 'kStencil',
  'stereoRigCamera': 'kStereoCameraMaster',
  'stitchAsNurbsShell': 'kStitchAsNurbsShell',
  'stitchSrf': 'kStitchSrf',
  'stroke': 'kStroke',
  'strokeGlobals': 'kStrokeGlobals',
  'stucco': 'kStucco',
  'studioClearCoat': 'kStudioClearCoat',
  'styleCurve': 'kStyleCurve',
  'subCurve': 'kSubCurve',
  'subSurface': 'kSubSurface',
  'subdAddTopology': 'kSubdAddTopology',
  'subdAutoProj': 'kSubdAutoProj',
  'subdBase': 'kDependencyNode',
  'subdBlindData': 'kSubdBlindData',
  'subdCleanTopology': 'kSubdCleanTopology',
  'subdHierBlind': 'kSubdHierBlind',
  'subdLayoutUV': 'kSubdLayoutUV',
  'subdMapCut': 'kSubdMapCut',
  'subdMapSewMove': 'kSubdMapSewMove',
  'subdModifier': 'kSubdModifier',
  'subdModifierUV': 'kSubdModifier',
  'subdModifierWorld': 'kSubdModifier',
  'subdPlanarProj': 'kSubdPlanProj',
  'subdTweak': 'kSubdTweak',
  'subdTweakUV': 'kSubdTweakUV',
  'subdiv': 'kSubdiv',
  'subdivCollapse': 'kSubdivCollapse',
  'subdivComponentId': 'kSubdivCompId',
  'subdivReverseFaces': 'kSubdivReverseFaces',
  'subdivSurfaceVarGroup': 'kSurfaceVarGroup',
  'subdivToNurbs': 'kSubdivToNurbs',
  'subdivToPoly': 'kSubdivToPoly',
  'surfaceInfo': 'kSurfaceInfo',
  'surfaceLuminance': 'kSurfaceLuminance',
  'surfaceShader': 'kSurfaceShader',
  'surfaceShape': 'kSurface',
  'surfaceVarGroup': 'kSurfaceVarGroup',
  'symmetryConstraint': 'kSymmetryConstraint',
  'tangentConstraint': 'kTangentConstraint',
  'tension': 'kTension',
  'texLattice': 'kTexLattice',
  'texture2d': 'kTexture2d',
  'texture3d': 'kTexture3d',
  'textureBakeSet': 'kTextureBakeSet',
  'textureDeformer': 'kTextureDeformer',
  'textureDeformerHandle': 'kTextureDeformerHandle',
  'textureEnv': 'kTextureEnv',
  'textureToGeom': 'kDependencyNode',
  'threadedDevice': 'kThreadedDevice',
  'time': 'kTime',
  'timeEditor': 'kTimeEditor',
  'timeEditorAnimSource': 'kTimeEditorAnimSource',
  'timeEditorClip': 'kTimeEditorClip',
  'timeEditorClipBase': 'kTimeEditorClipBase',
  'timeEditorClipEvaluator': 'kTimeEditorClipEvaluator',
  'timeEditorInterpolator': 'kTimeEditorInterpolator',
  'timeEditorTracks': 'kTimeEditorTracks',
  'timeFunction': 'kTimeFunction',
  'timeSliderBookmark': 'kDependencyNode',
  'timeToUnitConversion': 'kTimeToUnitConversion',
  'timeWarp': 'kTimeWarp',
  'toonLineAttributes': 'kToonLineAttributes',
  'trackInfoManager': 'kTrackInfoManager',
  'transferAttributes': 'kTransferAttributes',
  'transferFalloff': 'kTransferFalloff',
  'transform': 'kTransform',
  'transformGeometry': 'kTransformGeometry',
  'trim': 'kTrim',
  'trimWithBoundaries': 'kTrimWithBoundaries',
  'tripleShadingSwitch': 'kTripleShadingSwitch',
  'turbulenceField': 'kTurbulence',
  'tweak': 'kTweak',
  'ufeProxyCameraShape': 'kCamera',
  'ufeProxyTransform': 'kUfeProxyTransform',
  'uniformFalloff': 'kUniformFalloff',
  'uniformField': 'kUniform',
  'unitConversion': 'kUnitConversion',
  'unitToTimeConversion': 'kUnitToTimeConversion',
  'unknown': 'kUnknown',
  'unknownDag': 'kUnknownDag',
  'unknownTransform': 'kUnknownTransform',
  'untrim': 'kUntrim',
  'useBackground': 'kUseBackground',
  'uvChooser': 'kUvChooser',
  'uvPin': 'kUVPin',
  'vectorProduct': 'kVectorProduct',
  'vectorRenderGlobals': 'kDependencyNode',
  'vertexBakeSet': 'kVertexBakeSet',
  'viewColorManager': 'kViewColorManager',
  'volumeAxisField': 'kVolumeAxis',
  'volumeFog': 'kVolumeFog',
  'volumeLight': 'kVolumeLight',
  'volumeNoise': 'kVolumeNoise',
  'volumeShader': 'kVolumeShader',
  'vortexField': 'kVortex',
  'water': 'kWater',
  'weightGeometryFilter': 'kWeightGeometryFilt',
  'wire': 'kWire',
  'wood': 'kWood',
  'wrap': 'kWrapFilter',
  'wtAddMatrix': 'kMatrixWtAdd',
  'xformManip': 'kXformManip'},
 {'kAISEnvFacade': 'maya.OpenMaya.MFnDependencyNode',
  'kAddDoubleLinear': 'maya.OpenMaya.MFnDependencyNode',
  'kAdskMaterial': 'maya.OpenMaya.MFnDependencyNode',
  'kAffect': 'maya.OpenMaya.MFnDependencyNode',
  'kAimConstraint': 'maya.OpenMaya.MFnTransform',
  'kAimMatrix': 'maya.OpenMaya.MFnDependencyNode',
  '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',
  'kBirailSrf': 'maya.OpenMaya.MFnDependencyNode',
  'kBlend': 'maya.OpenMaya.MFnDependencyNode',
  'kBlendColorSet': 'maya.OpenMaya.MFnDependencyNode',
  'kBlendColors': 'maya.OpenMaya.MFnDependencyNode',
  'kBlendDevice': 'maya.OpenMaya.MFnDependencyNode',
  'kBlendFalloff': 'maya.OpenMaya.MFnDependencyNode',
  'kBlendMatrix': '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',
  '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',
  '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',
  'kComponentFalloff': 'maya.OpenMaya.MFnDependencyNode',
  'kComponentListData': 'maya.OpenMaya.MFnComponentListData',
  'kComponentMatch': 'maya.OpenMaya.MFnDependencyNode',
  'kComposeMatrix': 'maya.OpenMaya.MFnDependencyNode',
  'kCompoundAttribute': 'maya.OpenMaya.MFnCompoundAttribute',
  'kCondition': 'maya.OpenMaya.MFnDependencyNode',
  'kCone': 'maya.OpenMaya.MFnDependencyNode',
  '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',
  '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',
  'kDecomposeMatrix': 'maya.OpenMaya.MFnDependencyNode',
  'kDefaultLightList': 'maya.OpenMaya.MFnDependencyNode',
  'kDeformBend': 'maya.OpenMaya.MFnDagNode',
  'kDeformFlare': 'maya.OpenMaya.MFnDagNode',
  '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',
  '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',
  'kFalloffEval': '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',
  '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',
  'kMaterialTemplate': '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',
  'kMorph': 'maya.OpenMayaAnim.MFnWeightGeometryFilter',
  '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',
  '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',
  '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',
  'kPickMatrix': 'maya.OpenMaya.MFnDependencyNode',
  'kPlace2dTexture': 'maya.OpenMaya.MFnDependencyNode',
  'kPlace3dTexture': 'maya.OpenMaya.MFnTransform',
  'kPlanarTrimSrf': 'maya.OpenMaya.MFnDependencyNode',
  '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',
  'kPluginThreadedDevice': 'maya.OpenMaya.MFnDependencyNode',
  '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',
  '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',
  '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',
  'kPrimitive': 'maya.OpenMaya.MFnDependencyNode',
  'kPrimitiveFalloff': 'maya.OpenMaya.MFnTransform',
  'kProjectCurve': 'maya.OpenMaya.MFnDependencyNode',
  'kProjectTangent': 'maya.OpenMaya.MFnDependencyNode',
  'kProjection': 'maya.OpenMaya.MFnDependencyNode',
  'kProximityPin': 'maya.OpenMaya.MFnDependencyNode',
  'kProximityWrap': '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',
  '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',
  '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',
  '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',
  'kSolidify': 'maya.OpenMayaAnim.MFnWeightGeometryFilter',
  'kSphere': 'maya.OpenMaya.MFnDependencyNode',
  'kSphereData': 'maya.OpenMaya.MFnSphereData',
  'kSplineSolver': 'maya.OpenMayaAnim.MFnIkSolver',
  'kSpotLight': 'maya.OpenMaya.MFnSpotLight',
  'kSpring': 'maya.OpenMaya.MFnDagNode',
  'kSquareSrf': 'maya.OpenMaya.MFnDependencyNode',
  'kStandardSurface': 'maya.OpenMaya.MFnStandardSurfaceShader',
  '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',
  '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',
  'kTexture2d': 'maya.OpenMaya.MFnDependencyNode',
  'kTexture3d': 'maya.OpenMaya.MFnDependencyNode',
  'kTextureBakeSet': 'maya.OpenMaya.MFnSet',
  'kTextureDeformer': 'maya.OpenMayaAnim.MFnWeightGeometryFilter',
  'kTextureDeformerHandle': 'maya.OpenMaya.MFnTransform',
  'kTextureEnv': 'maya.OpenMaya.MFnDependencyNode',
  'kTextureList': 'maya.OpenMaya.MFnDependencyNode',
  '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',
  'kTransferFalloff': 'maya.OpenMaya.MFnDependencyNode',
  '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',
  'kUVPin': 'maya.OpenMaya.MFnDependencyNode',
  'kUfeProxyTransform': 'maya.OpenMaya.MFnTransform',
  'kUint64SingleIndexedComponent': 'maya.OpenMaya.MFnUint64SingleIndexedComponent',
  'kUniform': 'maya.OpenMayaFX.MFnUniformField',
  'kUniformFalloff': 'maya.OpenMaya.MFnDependencyNode',
  '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 follicles.',
                                                         '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 follicles.',
                                                         '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})"}},
              'methods': {},
              '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)"}},
  'MAddRemoveAttrEdit': {'enums': {}, 'methods': {}, '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'),
                             ('setUnit', 'unit'),
                             ('setValue', 'value')],
             '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': 'Unit conversion.',
                                 'inArgs': ['otherUnit'],
                                 'outArgs': [],
                                 'returnInfo': {'doc': 'The current value in the given units',
                                                'qualifiers': [],
                                                'type': 'double'},
                                 'returnType': 'double',
                                 'static': False,
                                 'typeQualifiers': {},
                                 'types': {'otherUnit': ('MAngle', 'Unit')}}],
                         'asAngMinutes': [{'argInfo': {},
                                           'args': [],
                                           'defaults': {},
                                           'deprecated': False,
                                           'doc': 'Convert to minutes of arc.',
                                           'inArgs': [],
                                           'outArgs': [],
                                           'returnInfo': {'doc': 'The current value in the minutes of arc',
                                                          'qualifiers': [],
                                                          'type': 'double'},
                                           'returnType': 'double',
                                           'static': False,
                                           'typeQualifiers': {},
                                           'types': {}}],
                         'asAngSeconds': [{'argInfo': {},
                                           'args': [],
                                           'defaults': {},
                                           'deprecated': False,
                                           'doc': 'Convert to seconds of arc.',
                                           'inArgs': [],
                                           'outArgs': [],
                                           'returnInfo': {'doc': 'The current value in the seconds of arc',
                                                          'qualifiers': [],
                                                          'type': 'double'},
                                           'returnType': 'double',
                                           'static': False,
                                           'typeQualifiers': {},
                                           'types': {}}],
                         'asDegrees': [{'argInfo': {},
                                        'args': [],
                                        'defaults': {},
                                        'deprecated': False,
                                        'doc': 'Convert to degrees.',
                                        'inArgs': [],
                                        'outArgs': [],
                                        'returnInfo': {'doc': 'The current value in the degrees',
                                                       'qualifiers': [],
                                                       'type': 'double'},
                                        'returnType': 'double',
                                        'static': False,
                                        'typeQualifiers': {},
                                        'types': {}}],
                         'asRadians': [{'argInfo': {},
                                        'args': [],
                                        'defaults': {},
                                        'deprecated': False,
                                        'doc': 'Convert to radians.',
                                        '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': 'Unit conversion.',
                                      'inArgs': ['otherUnit'],
                                      'outArgs': [],
                                      'returnInfo': {'doc': 'The current value in the given units',
                                                     'qualifiers': [],
                                                     'type': 'double'},
                                      'returnType': 'double',
                                      'static': False,
                                      'typeQualifiers': {},
                                      'types': {'otherUnit': ('MAngle',
                                                              'Unit')}}],
                         'className': [{'argInfo': {},
                                        'args': [],
                                        'defaults': {},
                                        'deprecated': False,
                                        'doc': 'Returns the name of this class.',
                                        'inArgs': [],
                                        'outArgs': [],
                                        'returnInfo': {'doc': 'The name of this class.',
                                                       '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': 'Unit conversion.',
                                           'inArgs': ['internalValue'],
                                           'outArgs': [],
                                           'returnInfo': {'doc': 'The value in UI units',
                                                          'qualifiers': [],
                                                          'type': 'double'},
                                           'returnType': 'double',
                                           'static': True,
                                           'typeQualifiers': {},
                                           'types': {'internalValue': 'double'}}],
                         'internalUnit': [{'argInfo': {},
                                           'args': [],
                                           'defaults': {},
                                           'deprecated': False,
                                           'doc': 'Internal unit.',
                                           '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': 'This method is obsolete. [as of Maya 2019]',
                                              'inArgs': ['internalUnit'],
                                              'inverse': ('internalUnit', True),
                                              'outArgs': [],
                                              'returnInfo': {'doc': '',
                                                             'qualifiers': [],
                                                             'type': None},
                                              'returnType': None,
                                              'static': True,
                                              'typeQualifiers': {},
                                              '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': 'Set working unit.',
                                        'inArgs': ['newUnit'],
                                        'outArgs': [],
                                        'returnInfo': {'doc': '',
                                                       'qualifiers': [],
                                                       'type': None},
                                        'returnType': None,
                                        'static': True,
                                        'typeQualifiers': {},
                                        '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': 'Set current unit.',
                                      'inArgs': ['newUnit'],
                                      'inverse': ('unit', True),
                                      'outArgs': [],
                                      'returnInfo': {'doc': '',
                                                     'qualifiers': [],
                                                     'type': None},
                                      'returnType': None,
                                      'static': False,
                                      'typeQualifiers': {},
                                      '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': 'Set current value.',
                                       'inArgs': ['newValue'],
                                       'inverse': ('value', True),
                                       'outArgs': [],
                                       'returnInfo': {'doc': '',
                                                      'qualifiers': [],
                                                      'type': None},
                                       'returnType': None,
                                       'static': False,
                                       'typeQualifiers': {},
                                       'types': {'newValue': 'double'}}],
                         'uiToInternal': [{'argInfo': {'uiValue': {'doc': 'a value in UI units',
                                                                   'type': 'double'}},
                                           'args': [('uiValue',
                                                     'double',
                                                     'in')],
                                           'defaults': {},
                                           'deprecated': False,
                                           'doc': 'Unit conversion.',
                                           'inArgs': ['uiValue'],
                                           'outArgs': [],
                                           'returnInfo': {'doc': 'The value in internal units.',
                                                          'qualifiers': [],
                                                          'type': 'double'},
                                           'returnType': 'double',
                                           'static': True,
                                           'typeQualifiers': {},
                                           'types': {'uiValue': 'double'}}],
                         'uiUnit': [{'argInfo': {},
                                     'args': [],
                                     'defaults': {},
                                     'deprecated': False,
                                     'doc': 'Working unit.',
                                     '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': 'Current unit.',
                                   'inArgs': [],
                                   'inverse': ('setUnit', False),
                                   'outArgs': [],
                                   'returnInfo': {'doc': 'An element of the MAngle::Unit enum',
                                                  'qualifiers': [],
                                                  'type': ('MAngle', 'Unit')},
                                   'returnType': ('MAngle', 'Unit'),
                                   'static': False,
                                   'typeQualifiers': {},
                                   'types': {}}],
                         'value': [{'argInfo': {},
                                    'args': [],
                                    'defaults': {},
                                    'deprecated': False,
                                    'doc': 'Current value.',
                                    'inArgs': [],
                                    'inverse': ('setValue', False),
                                    'outArgs': [],
                                    'returnInfo': {'doc': 'The current value of the instance',
                                                   '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})"}},
                   'methods': {},
                   '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)"}},
  'MAnimCurveChange': {'enums': {}, 'methods': {}, 'pymelEnums': {}},
  'MAnimCurveClipboard': {'enums': {}, 'methods': {}, 'pymelEnums': {}},
  'MAnimCurveClipboardItem': {'enums': {}, 'methods': {}, 'pymelEnums': {}},
  'MAnimCurveClipboardItemArray': {'enums': {},
                                   'methods': {},
                                   'pymelEnums': {}},
  'MAnimMessage': {'enums': {}, 'methods': {}, 'pymelEnums': {}},
  'MAnimUtil': {'enums': {}, 'methods': {}, 'pymelEnums': {}},
  'MArgDatabase': {'enums': {}, 'methods': {}, 'pymelEnums': {}},
  'MArgList': {'enums': {}, 'methods': {}, 'pymelEnums': {}},
  'MArgParser': {'enums': {}, 'methods': {}, 'pymelEnums': {}},
  'MArrayDataBuilder': {'enums': {}, 'methods': {}, 'pymelEnums': {}},
  'MArrayDataHandle': {'enums': {}, 'methods': {}, '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})"}},
                      'methods': {},
                      'pymelEnums': {'MIndexType': "Enum('MIndexType', [('integer', 0), ('kInteger', 0), ('float', 1), ('kFloat', 1)], multiKeys=True)"}},
  'MAttributePattern': {'enums': {}, 'methods': {}, 'pymelEnums': {}},
  'MAttributePatternArray': {'enums': {}, 'methods': {}, 'pymelEnums': {}},
  'MAttributeSpec': {'enums': {}, 'methods': {}, 'pymelEnums': {}},
  'MAttributeSpecArray': {'enums': {}, 'methods': {}, 'pymelEnums': {}},
  'MBoundingBox': {'enums': {},
                   'methods': {'center': [{'argInfo': {},
                                           'args': [],
                                           'defaults': {},
                                           'deprecated': False,
                                           'doc': 'Returns the center of the bounding box.',
                                           'inArgs': [],
                                           'outArgs': [],
                                           'returnInfo': {'doc': 'The center of the bounding box',
                                                          'qualifiers': [],
                                                          'type': 'MPoint'},
                                           'returnType': 'MPoint',
                                           'static': False,
                                           'typeQualifiers': {},
                                           'types': {}}],
                               'clear': [{'argInfo': {},
                                          'args': [],
                                          'defaults': {},
                                          'deprecated': False,
                                          'doc': 'Empties the current bounding box.',
                                          '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': 'Returns 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': 'Returns 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': 'Expand 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': 'Expand 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': 'Returns 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': 'Returns 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',
                                                                          '&']},
                                               'types': {'box': 'MBoundingBox',
                                                         'tol': 'double'}}],
                               'max': [{'argInfo': {},
                                        'args': [],
                                        'defaults': {},
                                        'deprecated': False,
                                        'doc': "Returns 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': "Returns 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': 'Apply 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': 'Returns 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': {}},
  'MCacheConfigRuleRegistry': {'enums': {}, 'methods': {}, '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})"}},
                              'methods': {},
                              '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)"}},
  'MCacheSchema': {'enums': {}, 'methods': {}, 'pymelEnums': {}},
  'MCacheSchemaAttributesIterator': {'enums': {},
                                     'methods': {},
                                     'pymelEnums': {}},
  'MCallbackIdArray': {'enums': {}, 'methods': {}, 'pymelEnums': {}},
  'MCameraMessage': {'enums': {}, 'methods': {}, 'pymelEnums': {}},
  'MCameraSetMessage': {'enums': {}, 'methods': {}, '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': 'Add operator.',
                                      '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'}}],
                         '__eq__': [{'argInfo': {'other': {'doc': 'Color to which this color will be compared.',
                                                           'type': 'MColor'}},
                                     'args': [('other', 'MColor', 'in')],
                                     'defaults': {},
                                     'deprecated': False,
                                     'doc': 'Equality operator.',
                                     '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': 'Index operator.',
                                          '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': 'In place add operator.',
                                       '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'}}],
                         '__imul__': [{'argInfo': {'scalar': {'doc': 'Color multiplication factor.',
                                                              'type': 'float'}},
                                       'args': [('scalar', 'float', 'in')],
                                       'defaults': {},
                                       'deprecated': False,
                                       'doc': 'In place multiply operator.',
                                       'inArgs': ['scalar'],
                                       'outArgs': [],
                                       'returnInfo': {'doc': 'A reference to the color object which was modified.',
                                                      'qualifiers': ['&'],
                                                      'type': 'MColor'},
                                       'returnType': 'MColor',
                                       'static': False,
                                       'typeQualifiers': {},
                                       'types': {'scalar': 'float'}},
                                      {'argInfo': {'other': {'doc': 'Color to be multiplied with this color.',
                                                             'type': 'MColor'}},
                                       'args': [('other', 'MColor', 'in')],
                                       'defaults': {},
                                       'deprecated': False,
                                       'doc': 'In place multiply operator.',
                                       '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'}}],
                         '__itruediv__': [{'argInfo': {'scalar': {'doc': 'Color division factor.',
                                                                  'type': 'float'}},
                                           'args': [('scalar', 'float', 'in')],
                                           'defaults': {},
                                           'deprecated': False,
                                           'doc': 'In place divide operator.',
                                           'inArgs': ['scalar'],
                                           'outArgs': [],
                                           'returnInfo': {'doc': 'A reference to the color whose value was modified.',
                                                          'qualifiers': ['&'],
                                                          'type': 'MColor'},
                                           'returnType': 'MColor',
                                           'static': False,
                                           'typeQualifiers': {},
                                           'types': {'scalar': 'float'}}],
                         '__mul__': [{'argInfo': {'scalar': {'doc': 'Color multiplication factor.',
                                                             'type': 'float'}},
                                      'args': [('scalar', 'float', 'in')],
                                      'defaults': {},
                                      'deprecated': False,
                                      'doc': 'Multiply operator.',
                                      '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': {},
                                      'types': {'scalar': 'float'}},
                                     {'argInfo': {'other': {'doc': 'Color to be multiplied with this color.',
                                                            'type': 'MColor'}},
                                      'args': [('other', 'MColor', 'in')],
                                      'defaults': {},
                                      'deprecated': False,
                                      'doc': 'Multiply operator.',
                                      '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'}}],
                         '__ne__': [{'argInfo': {'other': {'doc': 'Color to which this color will be compared.',
                                                           'type': 'MColor'}},
                                     'args': [('other', 'MColor', 'in')],
                                     'defaults': {},
                                     'deprecated': False,
                                     'doc': 'Inequality operator.',
                                     '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': 'Unary minus operator.',
                                      'inArgs': [],
                                      'outArgs': [],
                                      'returnInfo': {'doc': 'The negated color.',
                                                     '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': 'Substraction operator.',
                                      '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'}}],
                         '__truediv__': [{'argInfo': {'scalar': {'doc': 'Color division factor.',
                                                                 'type': 'float'}},
                                          'args': [('scalar', 'float', 'in')],
                                          'defaults': {},
                                          'deprecated': False,
                                          'doc': 'Divide operator.',
                                          'inArgs': ['scalar'],
                                          'outArgs': [],
                                          'returnInfo': {'doc': 'A new MColor object representing the color divided by the scalar.',
                                                         'qualifiers': [],
                                                         'type': 'MColor'},
                                          'returnType': 'MColor',
                                          'static': False,
                                          'typeQualifiers': {},
                                          'types': {'scalar': 'float'}}],
                         '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': 'Color component accessor.',
                                  'inArgs': [],
                                  'outArgs': ['d'],
                                  'returnInfo': {'doc': 'Always returns bool true.',
                                                 'qualifiers': [],
                                                 'type': 'bool'},
                                  'returnType': 'bool',
                                  'static': False,
                                  'typeQualifiers': {},
                                  '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': 'Color component accessor.',
                                  'inArgs': ['colorModel'],
                                  'outArgs': ['c1', 'c2', 'c3'],
                                  'returnInfo': {'doc': 'Always returns bool true.',
                                                 'qualifiers': [],
                                                 'type': 'bool'},
                                  'returnType': 'bool',
                                  'static': False,
                                  'typeQualifiers': {'c1': ['&'],
                                                     'c2': ['&'],
                                                     'c3': ['&']},
                                  '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': 'Color component accessor.',
                                  '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': ['&']},
                                  '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': 'Color component assigment.',
                                  'inArgs': ['colorModel',
                                             'c1',
                                             'c2',
                                             'c3',
                                             'alpha'],
                                  'outArgs': [],
                                  'returnInfo': {'doc': 'Always returns bool true.',
                                                 'qualifiers': [],
                                                 'type': 'bool'},
                                  'returnType': 'bool',
                                  'static': False,
                                  'typeQualifiers': {},
                                  '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': {}, 'methods': {}, 'pymelEnums': {}},
  'MCommandMessage': {'enums': {'MProcType': {'valueDocs': {},
                                              'values': "Enum('MProcType', {'kMELProc': 0, 'kMELCommand': 1})"},
                                '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': {},
                      'pymelEnums': {'MProcType': "Enum('MProcType', [('proc', 0), ('kMELProc', 0), ('command', 1), ('kMELCommand', 1)], multiKeys=True)",
                                     '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': {},
                                        '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': {},
                     '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': {},
                                'pymelEnums': {'MpathType': "Enum('MpathType', [('relativePath', 0), ('kRelativePath', 0), ('fullPathImage', 1), ('kFullPathImage', 1), ('fullPathTmp', 2), ('kFullPathTmp', 2)], multiKeys=True)"}},
  'MComputation': {'enums': {}, 'methods': {}, 'pymelEnums': {}},
  'MConditionMessage': {'enums': {}, 'methods': {}, 'pymelEnums': {}},
  'MConnectDisconnectAttrEdit': {'enums': {}, 'methods': {}, 'pymelEnums': {}},
  'MContainerMessage': {'enums': {}, 'methods': {}, 'pymelEnums': {}},
  'MCursor': {'enums': {}, 'methods': {}, 'pymelEnums': {}},
  'MCurveAttribute': {'enums': {}, 'methods': {}, 'pymelEnums': {}},
  'MD3D9Renderer': {'enums': {}, 'methods': {}, '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': {}, 'pymelEnums': {}},
  'MDGContextGuard': {'enums': {}, 'methods': {}, 'pymelEnums': {}},
  'MDGMessage': {'enums': {}, 'methods': {}, 'pymelEnums': {}},
  'MDGModifier': {'enums': {}, 'methods': {}, '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': 'a dummy value (used for looping through the message types)',
                                                         'kParentAdded': 'a parent was added to a DAG node',
                                                         'kParentRemoved': 'a parent was removed from a DAG node',
                                                         'last': 'a dummy value (used for looping through the message types)',
                                                         'parentAdded': 'a parent was added to a DAG node',
                                                         '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})"},
                            'MatrixModifiedFlags': {'valueDocs': {'all': 'All.',
                                                                  'kAll': 'All.',
                                                                  'kRotateOrder': 'Rotation order.',
                                                                  'kRotateOrient': 'Rotation orientation around all axis.',
                                                                  'kRotateOrientX': 'Rotation orientation around the X axis.',
                                                                  'kRotateOrientY': 'Rotation orientation around the Y axis.',
                                                                  'kRotateOrientZ': 'Rotation orientation around the Z axis.',
                                                                  'kRotatePivot': 'Rotate pivot in all axis.',
                                                                  'kRotatePivotTrans': 'Rotate pivot translation for all axis.',
                                                                  'kRotatePivotX': 'Rotate pivot X position.',
                                                                  'kRotatePivotY': 'Rotate pivot Y position.',
                                                                  'kRotatePivotZ': 'Rotate pivot Z position.',
                                                                  'kRotateTransX': 'Rotate pivot translation along X axis.',
                                                                  'kRotateTransY': 'Rotate pivot translation along Y axis.',
                                                                  'kRotateTransZ': 'Rotate pivot translation along Z axis.',
                                                                  'kRotateX': 'Rotate around the X axis.',
                                                                  'kRotateY': 'Rotate around the Y axis.',
                                                                  'kRotateZ': 'Rotate around the Z axis.',
                                                                  'kRotation': 'Rotation around all axis.',
                                                                  'kScale': 'Scale in all axis.',
                                                                  'kScalePivot': 'Scale pivot in all axis.',
                                                                  'kScalePivotTrans': 'Scale pivot translation for all axis.',
                                                                  'kScalePivotX': 'Scale pivot X position.',
                                                                  'kScalePivotY': 'Scale pivot Y position.',
                                                                  'kScalePivotZ': 'Scale pivot Z position.',
                                                                  'kScaleTransX': 'Scale pivot translation along X axis.',
                                                                  'kScaleTransY': 'Scale pivot translation along Y axis.',
                                                                  'kScaleTransZ': 'Scale pivot translation along Z axis.',
                                                                  'kScaleX': 'Scale in the X axis.',
                                                                  'kScaleY': 'Scale in the Y axis.',
                                                                  'kScaleZ': 'Scale in the Z axis.',
                                                                  'kShear': 'Shear in all axis.',
                                                                  'kShearXY': 'Shear in the XY plane.',
                                                                  'kShearXZ': 'Shear in the XZ plane.',
                                                                  'kShearYZ': 'Shear in the YZ plane.',
                                                                  'kTranslateX': 'Translate along the X axis.',
                                                                  'kTranslateY': 'Translate along the Y axis.',
                                                                  'kTranslateZ': 'Translate along the Z axis.',
                                                                  'kTranslation': 'Translation along all axis.',
                                                                  'rotateOrder': 'Rotation order.',
                                                                  'rotateOrient': 'Rotation orientation around all axis.',
                                                                  'rotateOrientX': 'Rotation orientation around the X axis.',
                                                                  'rotateOrientY': 'Rotation orientation around the Y axis.',
                                                                  'rotateOrientZ': 'Rotation orientation around the Z axis.',
                                                                  'rotatePivot': 'Rotate pivot in all axis.',
                                                                  'rotatePivotTrans': 'Rotate pivot translation for all axis.',
                                                                  'rotatePivotX': 'Rotate pivot X position.',
                                                                  'rotatePivotY': 'Rotate pivot Y position.',
                                                                  'rotatePivotZ': 'Rotate pivot Z position.',
                                                                  'rotateTransX': 'Rotate pivot translation along X axis.',
                                                                  'rotateTransY': 'Rotate pivot translation along Y axis.',
                                                                  'rotateTransZ': 'Rotate pivot translation along Z axis.',
                                                                  'rotateX': 'Rotate around the X axis.',
                                                                  'rotateY': 'Rotate around the Y axis.',
                                                                  'rotateZ': 'Rotate around the Z axis.',
                                                                  'rotation': 'Rotation around all axis.',
                                                                  'scale': 'Scale in all axis.',
                                                                  'scalePivot': 'Scale pivot in all axis.',
                                                                  'scalePivotTrans': 'Scale pivot translation for all axis.',
                                                                  'scalePivotX': 'Scale pivot X position.',
                                                                  'scalePivotY': 'Scale pivot Y position.',
                                                                  'scalePivotZ': 'Scale pivot Z position.',
                                                                  'scaleTransX': 'Scale pivot translation along X axis.',
                                                                  'scaleTransY': 'Scale pivot translation along Y axis.',
                                                                  'scaleTransZ': 'Scale pivot translation along Z axis.',
                                                                  'scaleX': 'Scale in the X axis.',
                                                                  'scaleY': 'Scale in the Y axis.',
                                                                  'scaleZ': 'Scale in the Z axis.',
                                                                  'shear': 'Shear in all axis.',
                                                                  'shearXY': 'Shear in the XY plane.',
                                                                  'shearXZ': 'Shear in the XZ plane.',
                                                                  'shearYZ': 'Shear in the YZ plane.',
                                                                  'translateX': 'Translate along the X axis.',
                                                                  'translateY': 'Translate along the Y axis.',
                                                                  'translateZ': 'Translate along the Z axis.',
                                                                  'translation': 'Translation along all axis.'},
                                                    'values': "Enum('MatrixModifiedFlags', {'kScaleX': 1, 'kScaleY': 2, 'kScaleZ': 4, 'kScale': 7, 'kShearXY': 8, 'kShearXZ': 16, 'kShearYZ': 32, 'kShear': 56, 'kRotateX': 64, 'kRotateY': 128, 'kRotateZ': 256, 'kRotation': 448, 'kTranslateX': 512, 'kTranslateY': 1024, 'kTranslateZ': 2048, 'kTranslation': 3584, 'kScalePivotX': 4096, 'kScalePivotY': 8192, 'kScalePivotZ': 16384, 'kScalePivot': 28672, 'kRotatePivotX': 32768, 'kRotatePivotY': 65536, 'kRotatePivotZ': 131072, 'kRotatePivot': 229376, 'kScaleTransX': 262144, 'kScaleTransY': 524288, 'kScaleTransZ': 1048576, 'kScalePivotTrans': 1835008, 'kRotateTransX': 2097152, 'kRotateTransY': 4194304, 'kRotateTransZ': 8388608, 'kRotatePivotTrans': 14680064, 'kRotateOrientX': 16777216, 'kRotateOrientY': 33554432, 'kRotateOrientZ': 67108864, 'kRotateOrient': 117440512, 'kRotateOrder': 134217728, 'kAll': 268435455})"}},
                  'methods': {},
                  '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)",
                                 'MatrixModifiedFlags': "Enum('MatrixModifiedFlags', [('scaleX', 1), ('kScaleX', 1), ('scaleY', 2), ('kScaleY', 2), ('scaleZ', 4), ('kScaleZ', 4), ('scale', 7), ('kScale', 7), ('shearXY', 8), ('kShearXY', 8), ('shearXZ', 16), ('kShearXZ', 16), ('shearYZ', 32), ('kShearYZ', 32), ('shear', 56), ('kShear', 56), ('rotateX', 64), ('kRotateX', 64), ('rotateY', 128), ('kRotateY', 128), ('rotateZ', 256), ('kRotateZ', 256), ('rotation', 448), ('kRotation', 448), ('translateX', 512), ('kTranslateX', 512), ('translateY', 1024), ('kTranslateY', 1024), ('translateZ', 2048), ('kTranslateZ', 2048), ('translation', 3584), ('kTranslation', 3584), ('scalePivotX', 4096), ('kScalePivotX', 4096), ('scalePivotY', 8192), ('kScalePivotY', 8192), ('scalePivotZ', 16384), ('kScalePivotZ', 16384), ('scalePivot', 28672), ('kScalePivot', 28672), ('rotatePivotX', 32768), ('kRotatePivotX', 32768), ('rotatePivotY', 65536), ('kRotatePivotY', 65536), ('rotatePivotZ', 131072), ('kRotatePivotZ', 131072), ('rotatePivot', 229376), ('kRotatePivot', 229376), ('scaleTransX', 262144), ('kScaleTransX', 262144), ('scaleTransY', 524288), ('kScaleTransY', 524288), ('scaleTransZ', 1048576), ('kScaleTransZ', 1048576), ('scalePivotTrans', 1835008), ('kScalePivotTrans', 1835008), ('rotateTransX', 2097152), ('kRotateTransX', 2097152), ('rotateTransY', 4194304), ('kRotateTransY', 4194304), ('rotateTransZ', 8388608), ('kRotateTransZ', 8388608), ('rotatePivotTrans', 14680064), ('kRotatePivotTrans', 14680064), ('rotateOrientX', 16777216), ('kRotateOrientX', 16777216), ('rotateOrientY', 33554432), ('kRotateOrientY', 33554432), ('rotateOrientZ', 67108864), ('kRotateOrientZ', 67108864), ('rotateOrient', 117440512), ('kRotateOrient', 117440512), ('rotateOrder', 134217728), ('kRotateOrder', 134217728), ('all', 268435455), ('kAll', 268435455)], multiKeys=True)"}},
  'MDagModifier': {'enums': {}, 'methods': {}, 'pymelEnums': {}},
  'MDagPath': {'enums': {}, 'methods': {}, 'pymelEnums': {}},
  'MDagPathArray': {'enums': {}, 'methods': {}, 'pymelEnums': {}},
  'MDataBlock': {'enums': {}, 'methods': {}, 'pymelEnums': {}},
  'MDataHandle': {'enums': {}, 'methods': {}, 'pymelEnums': {}},
  'MDeviceChannel': {'enums': {}, 'methods': {}, 'pymelEnums': {}},
  'MDeviceState': {'enums': {}, 'methods': {}, 'pymelEnums': {}},
  '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', {'kInvalid': 0, 'kInches': 1, 'kFeet': 2, 'kYards': 3, 'kMiles': 4, 'kMillimeters': 5, 'kCentimeters': 6, 'kKilometers': 7, 'kMeters': 8, 'kLast': 9})"}},
                'invertibles': [('setInternalUnit', 'internalUnit'),
                                ('setUnit', 'unit'),
                                ('setValue', 'value')],
                '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': 'Return 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': {},
                                    'types': {'otherUnit': ('MDistance',
                                                            'Unit')}}],
                            'asCentimeters': [{'argInfo': {},
                                               'args': [],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': 'Return 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': 'Return the current value of this instance in feet.',
                                        'inArgs': [],
                                        'outArgs': [],
                                        'returnInfo': {'doc': 'The current value in the feet',
                                                       'qualifiers': [],
                                                       'type': 'double'},
                                        'returnType': 'double',
                                        'static': False,
                                        'typeQualifiers': {},
                                        'types': {}}],
                            'asInches': [{'argInfo': {},
                                          'args': [],
                                          'defaults': {},
                                          'deprecated': False,
                                          'doc': 'Return the current value of this instance in inches.',
                                          'inArgs': [],
                                          'outArgs': [],
                                          'returnInfo': {'doc': 'The current value in the inches',
                                                         'qualifiers': [],
                                                         'type': 'double'},
                                          'returnType': 'double',
                                          'static': False,
                                          'typeQualifiers': {},
                                          'types': {}}],
                            'asKilometers': [{'argInfo': {},
                                              'args': [],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': 'Return the current value of this instance in kilometers.',
                                              'inArgs': [],
                                              'outArgs': [],
                                              'returnInfo': {'doc': 'The current value in the kilometers',
                                                             'qualifiers': [],
                                                             'type': 'double'},
                                              'returnType': 'double',
                                              'static': False,
                                              'typeQualifiers': {},
                                              'types': {}}],
                            'asMeters': [{'argInfo': {},
                                          'args': [],
                                          'defaults': {},
                                          'deprecated': False,
                                          'doc': 'Return the current value of this instance in meters.',
                                          'inArgs': [],
                                          'outArgs': [],
                                          'returnInfo': {'doc': 'The current value in the meters',
                                                         'qualifiers': [],
                                                         'type': 'double'},
                                          'returnType': 'double',
                                          'static': False,
                                          'typeQualifiers': {},
                                          'types': {}}],
                            'asMiles': [{'argInfo': {},
                                         'args': [],
                                         'defaults': {},
                                         'deprecated': False,
                                         'doc': 'Return the current value of this instance in miles.',
                                         'inArgs': [],
                                         'outArgs': [],
                                         'returnInfo': {'doc': 'The current value in the miles',
                                                        'qualifiers': [],
                                                        'type': 'double'},
                                         'returnType': 'double',
                                         'static': False,
                                         'typeQualifiers': {},
                                         'types': {}}],
                            'asMillimeters': [{'argInfo': {},
                                               'args': [],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': 'Return the current value of this instance in millimeters.',
                                               'inArgs': [],
                                               'outArgs': [],
                                               'returnInfo': {'doc': 'The current value in the millimeters',
                                                              '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': 'Return 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': {},
                                         'types': {'otherUnit': ('MDistance',
                                                                 'Unit')}}],
                            'asYards': [{'argInfo': {},
                                         'args': [],
                                         'defaults': {},
                                         'deprecated': False,
                                         'doc': 'Return the current value of this instance in yards.',
                                         'inArgs': [],
                                         'outArgs': [],
                                         'returnInfo': {'doc': 'The current value in the yards',
                                                        'qualifiers': [],
                                                        'type': 'double'},
                                         'returnType': 'double',
                                         'static': False,
                                         'typeQualifiers': {},
                                         'types': {}}],
                            'className': [{'argInfo': {},
                                           'args': [],
                                           'defaults': {},
                                           'deprecated': False,
                                           'doc': 'Returns the name of this class.',
                                           'inArgs': [],
                                           'outArgs': [],
                                           'returnInfo': {'doc': 'The name of this class.',
                                                          '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': 'Converts 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': {},
                                              'types': {'internalValue': 'double'}}],
                            'internalUnit': [{'argInfo': {},
                                              'args': [],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': 'Returns 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': 'This method is obsolete. [as of Maya 2019]',
                                                 'inArgs': ['internalUnit'],
                                                 'inverse': ('internalUnit',
                                                             True),
                                                 'outArgs': [],
                                                 'returnInfo': {'doc': '',
                                                                'qualifiers': [],
                                                                'type': None},
                                                 'returnType': None,
                                                 'static': True,
                                                 'typeQualifiers': {},
                                                 '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': 'Set 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': {},
                                           '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': 'Set the units used by this instance.',
                                         'inArgs': ['newUnit'],
                                         'inverse': ('unit', True),
                                         'outArgs': [],
                                         'returnInfo': {'doc': '',
                                                        'qualifiers': [],
                                                        'type': None},
                                         'returnType': None,
                                         'static': False,
                                         'typeQualifiers': {},
                                         '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': 'Set the value of this instance',
                                          'inArgs': ['newValue'],
                                          'inverse': ('value', True),
                                          'outArgs': [],
                                          'returnInfo': {'doc': '',
                                                         'qualifiers': [],
                                                         'type': None},
                                          'returnType': None,
                                          'static': False,
                                          'typeQualifiers': {},
                                          'types': {'newValue': 'double'}}],
                            'uiToInternal': [{'argInfo': {'uiValue': {'doc': 'a value in UI units',
                                                                      'type': 'double'}},
                                              'args': [('uiValue',
                                                        'double',
                                                        'in')],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': 'Converts 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': {},
                                              'types': {'uiValue': 'double'}}],
                            'uiUnit': [{'argInfo': {},
                                        'args': [],
                                        'defaults': {},
                                        'deprecated': False,
                                        'doc': 'Returns 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': 'Return the units currently in effect for this instance.',
                                      'inArgs': [],
                                      'inverse': ('setUnit', False),
                                      'outArgs': [],
                                      'returnInfo': {'doc': 'An element of the MDistance::Unit enum',
                                                     'qualifiers': [],
                                                     'type': ('MDistance',
                                                              'Unit')},
                                      'returnType': ('MDistance', 'Unit'),
                                      'static': False,
                                      'typeQualifiers': {},
                                      'types': {}}],
                            'value': [{'argInfo': {},
                                       'args': [],
                                       'defaults': {},
                                       'deprecated': False,
                                       'doc': 'Return the value of the current instance in the currently set units.',
                                       'inArgs': [],
                                       'inverse': ('setValue', False),
                                       'outArgs': [],
                                       'returnInfo': {'doc': 'The current value of the instance',
                                                      'qualifiers': [],
                                                      'type': 'double'},
                                       'returnType': 'double',
                                       'static': False,
                                       'typeQualifiers': {},
                                       'types': {}}]},
                'pymelEnums': {'Unit': "Enum('Unit', [('invalid', 0), ('kInvalid', 0), ('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), ('last', 9), ('kLast', 9)], multiKeys=True)"},
                'pymelMethods': {'internalUnit': 'getInternalUnit',
                                 'unit': 'getUnit',
                                 'value': 'getValue'}},
  'MDoubleArray': {'enums': {}, 'methods': {}, 'pymelEnums': {}},
  'MDrawData': {'enums': {}, 'methods': {}, 'pymelEnums': {}},
  'MDrawInfo': {'enums': {}, 'methods': {}, 'pymelEnums': {}},
  'MDrawProcedureBase': {'enums': {}, 'methods': {}, 'pymelEnums': {}},
  'MDrawRequest': {'enums': {}, 'methods': {}, 'pymelEnums': {}},
  'MDrawRequestQueue': {'enums': {}, 'methods': {}, 'pymelEnums': {}},
  'MDrawTraversal': {'constants': {'kActiveItem': 0, 'kTemplateItem': 1},
                     'enums': {},
                     'methods': {},
                     'pymelEnums': {}},
  'MDynSweptLine': {'enums': {}, 'methods': {}, 'pymelEnums': {}},
  'MDynSweptTriangle': {'enums': {}, 'methods': {}, 'pymelEnums': {}},
  'MDynamicsUtil': {'enums': {}, 'methods': {}, '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})"}},
            'methods': {},
            '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': {},
                                                 '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': 'The 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': 'The 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': 'The 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'}}],
                                 '__iadd__': [{'argInfo': {'other': {'doc': 'the euler rotation to be added with this euler rotation',
                                                                     'type': 'MEulerRotation'}},
                                               'args': [('other',
                                                         'MEulerRotation',
                                                         'in')],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': 'The 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': 'The 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': 'The 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': 'The 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': {},
                                               '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': 'The 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': 'The 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': 'This 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': 'This 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': {},
                                              'types': {'other': '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': 'The 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': 'The 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': 'The 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': 'Euler rotation that results from the negation',
                                                             'qualifiers': [],
                                                             'type': 'MEulerRotation'},
                                              'returnType': 'MEulerRotation',
                                              'static': False,
                                              'typeQualifiers': {},
                                              'types': {}}],
                                 'alternateSolution': [{'argInfo': {},
                                                        'args': [],
                                                        'defaults': {},
                                                        'deprecated': False,
                                                        'doc': 'Returns 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': 'An alternate solution to this rotation',
                                                                       'qualifiers': [],
                                                                       'type': 'MEulerRotation'},
                                                        'returnType': 'MEulerRotation',
                                                        'static': False,
                                                        'typeQualifiers': {},
                                                        'types': {}}],
                                 'asMatrix': [{'argInfo': {},
                                               'args': [],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': 'Converts an euler rotation to a rotation matrix.',
                                               'inArgs': [],
                                               'outArgs': [],
                                               'returnInfo': {'doc': 'The rotation matrix that has been casted from the euler rotation',
                                                              'qualifiers': [],
                                                              'type': 'MMatrix'},
                                               'returnType': 'MMatrix',
                                               'static': False,
                                               'typeQualifiers': {},
                                               'types': {}}],
                                 'asQuaternion': [{'argInfo': {},
                                                   'args': [],
                                                   'defaults': {},
                                                   'deprecated': False,
                                                   'doc': 'Converts an euler rotation to a quaternion.',
                                                   'inArgs': [],
                                                   'outArgs': [],
                                                   'returnInfo': {'doc': 'The quaternion that has been casted from the euler rotation',
                                                                  'qualifiers': [],
                                                                  'type': 'MQuaternion'},
                                                   'returnType': 'MQuaternion',
                                                   'static': False,
                                                   'typeQualifiers': {},
                                                   'types': {}}],
                                 'asVector': [{'argInfo': {},
                                               'args': [],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': 'Converts an euler rotation to a vector. The rotation order component is dropped.',
                                               'inArgs': [],
                                               'outArgs': [],
                                               'returnInfo': {'doc': 'The vector that has been casted from the euler rotation',
                                                              'qualifiers': [],
                                                              'type': 'MVector'},
                                               'returnType': 'MVector',
                                               'static': False,
                                               'typeQualifiers': {},
                                               'types': {}}],
                                 'bound': [{'argInfo': {},
                                            'args': [],
                                            'defaults': {},
                                            'deprecated': False,
                                            'doc': 'Returns 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': 'The euler rotation that results from bounding this euler rotation',
                                                           'qualifiers': [],
                                                           'type': 'MEulerRotation'},
                                            'returnType': 'MEulerRotation',
                                            'static': False,
                                            'typeQualifiers': {},
                                            'types': {}}],
                                 'boundIt': [{'argInfo': {'src': {'doc': 'the input rotation that will be bound',
                                                                  'type': 'MEulerRotation'}},
                                              'args': [('src',
                                                        'MEulerRotation',
                                                        'in')],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': 'Sets 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': 'Bounds 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': 'A reference to the euler rotation that has been bound',
                                                             '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': 'Returns 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'}}],
                                 'closestSolution': [{'argInfo': {'dst': {'doc': 'the euler rotation to which the solution should be closest',
                                                                          'type': 'MEulerRotation'}},
                                                      'args': [('dst',
                                                                'MEulerRotation',
                                                                'in')],
                                                      'defaults': {},
                                                      'deprecated': False,
                                                      'doc': 'Returns 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'}}],
                                 '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': 'Decompose 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',
                                                                              '&']},
                                                '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': 'Perform 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': {'axis': ['const',
                                                                                      '&']},
                                                          'types': {'angle': 'double',
                                                                    'axis': 'MVector'}}],
                                 'inverse': [{'argInfo': {},
                                              'args': [],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': 'Returns the inverse of this euler rotation. The rotation order will be reversed.',
                                              'inArgs': [],
                                              'outArgs': [],
                                              'returnInfo': {'doc': 'Euler rotation that is the inverse of this euler rotation',
                                                             'qualifiers': [],
                                                             'type': 'MEulerRotation'},
                                              'returnType': 'MEulerRotation',
                                              'static': False,
                                              'typeQualifiers': {},
                                              'types': {}}],
                                 'invertIt': [{'argInfo': {},
                                               'args': [],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': 'Performs an in place inversion of this euler rotation. The rotation order will be reversed.',
                                               'inArgs': [],
                                               'outArgs': [],
                                               'returnInfo': {'doc': 'A reference to the euler rotation that has been inverted',
                                                              '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': 'This 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',
                                                                                '&']},
                                                   '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': 'This 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': {},
                                             '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': 'Returns 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': {},
                                              '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': 'Performs 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': {},
                                                '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': 'Sets 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': 'Sets 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': 'A reference to the euler rotation that has been set to an alternate solution',
                                                                            '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': 'Sets 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': 'Sets 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': 'Sets 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': 'Sets 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': 'Sets 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': {'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': 'Sets 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': {},
                                               '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': {}, 'pymelEnums': {}},
  'MEvaluationNode': {'enums': {}, 'methods': {}, 'pymelEnums': {}},
  'MEvaluationNodeIterator': {'enums': {}, 'methods': {}, 'pymelEnums': {}},
  'MEvent': {'enums': {'ModifierType': {'valueDocs': {},
                                        'values': "Enum('ModifierType', {'shiftKey': 1, 'controlKey': 4})"},
                       'MouseButtonType': {'valueDocs': {},
                                           'values': "Enum('MouseButtonType', {'kLeftMouse': 64, 'kMiddleMouse': 128})"}},
             'methods': {},
             'pymelEnums': {'ModifierType': "Enum('ModifierType', {'shiftKey': 1, 'controlKey': 4})",
                            'MouseButtonType': "Enum('MouseButtonType', [('leftMouse', 64), ('kLeftMouse', 64), ('middleMouse', 128), ('kMiddleMouse', 128)], multiKeys=True)"}},
  'MEventMessage': {'enums': {}, 'methods': {}, 'pymelEnums': {}},
  'MExternalContentInfoTable': {'enums': {}, 'methods': {}, 'pymelEnums': {}},
  'MExternalContentLocationTable': {'enums': {},
                                    'methods': {},
                                    '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': {},
                            'pymelEnums': {'MExternalDropStatus': "Enum('MExternalDropStatus', [('mayaDefault', 0), ('kMayaDefault', 0), ('noMayaDefaultAndAccept', 1), ('kNoMayaDefaultAndAccept', 1), ('noMayaDefaultAndNoAccept', 2), ('kNoMayaDefaultAndNoAccept', 2)], multiKeys=True)"}},
  'MExternalDropData': {'enums': {'KeyboardModifiers': {'valueDocs': {},
                                                        'values': "Enum('KeyboardModifiers', {'kNoModifier': 0, 'kShiftModifier': 33554432, 'kControlModifier': 67108864, 'kAltModifier': 134217728})"},
                                  'MouseButtons': {'valueDocs': {},
                                                   'values': "Enum('MouseButtons', [('kLeftButton', 1), ('kRightButton', 2), ('kMidButton', 4), ('kMiddleButton', 4)], multiKeys=True)"}},
                        'methods': {},
                        'pymelEnums': {'KeyboardModifiers': "Enum('KeyboardModifiers', [('noModifier', 0), ('kNoModifier', 0), ('shiftModifier', 33554432), ('kShiftModifier', 33554432), ('controlModifier', 67108864), ('kControlModifier', 67108864), ('altModifier', 134217728), ('kAltModifier', 134217728)], multiKeys=True)",
                                       'MouseButtons': "Enum('MouseButtons', [('leftButton', 1), ('kLeftButton', 1), ('rightButton', 2), ('kRightButton', 2), ('midButton', 4), ('kMidButton', 4), ('kMiddleButton', 4), ('middleButton', 4)], multiKeys=True)"}},
  'MFcurveEdit': {'enums': {}, 'methods': {}, 'pymelEnums': {}},
  'MFeedbackLine': {'enums': {}, 'methods': {}, 'pymelEnums': {}},
  '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})"},
                        'MayaFileFormatVersion': {'valueDocs': {},
                                                  'values': "Enum('MayaFileFormatVersion', {'kVersion4_0': 74, 'kVersion4_5': 83, 'kVersion5_0': 90, 'kVersion6_0': 105, 'kVersion6_5': 117, 'kVersion7_0': 128, 'kVersion8_0': 133, 'kVersion8_5': 139, 'kVersion2008': 144, 'kVersion2009': 147, 'kVersion2010': 152, 'kVersion2011': 156, 'kVersion2012': 161, 'kVersion2013': 167, 'kVersion2014': 179, 'kVersion2015': 184, 'kVersion2016': 192, 'kVersion2016R2': 198, 'kVersion2017': 201, 'kVersion2017Update3': 202, 'kVersion2017Update4': 203, 'kVersion2018': 210, 'kVersion2018Update2': 211, 'kVersion2018Update3': 212, 'kVersion2018Update4': 213, 'kVersion2019': 232, 'kVersion2020': 254})"},
                        '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})"}},
              'methods': {},
              '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)",
                             'MayaFileFormatVersion': "Enum('MayaFileFormatVersion', [('version4_0', 74), ('kVersion4_0', 74), ('version4_5', 83), ('kVersion4_5', 83), ('version5_0', 90), ('kVersion5_0', 90), ('version6_0', 105), ('kVersion6_0', 105), ('version6_5', 117), ('kVersion6_5', 117), ('version7_0', 128), ('kVersion7_0', 128), ('version8_0', 133), ('kVersion8_0', 133), ('version8_5', 139), ('kVersion8_5', 139), ('version2008', 144), ('kVersion2008', 144), ('version2009', 147), ('kVersion2009', 147), ('version2010', 152), ('kVersion2010', 152), ('version2011', 156), ('kVersion2011', 156), ('version2012', 161), ('kVersion2012', 161), ('version2013', 167), ('kVersion2013', 167), ('version2014', 179), ('kVersion2014', 179), ('version2015', 184), ('kVersion2015', 184), ('version2016', 192), ('kVersion2016', 192), ('version2016R2', 198), ('kVersion2016R2', 198), ('version2017', 201), ('kVersion2017', 201), ('version2017Update3', 202), ('kVersion2017Update3', 202), ('version2017Update4', 203), ('kVersion2017Update4', 203), ('version2018', 210), ('kVersion2018', 210), ('version2018Update2', 211), ('kVersion2018Update2', 211), ('version2018Update3', 212), ('kVersion2018Update3', 212), ('version2018Update4', 213), ('kVersion2018Update4', 213), ('version2019', 232), ('kVersion2019', 232), ('version2020', 254), ('kVersion2020', 254)], 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)"}},
  '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 MFileObject::exists() to determine if it is an existing path.',
                                                                 '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 MFileObject::exists() to determine if it is an existing path.',
                                                                 '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})"}},
                  'methods': {},
                  '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)"}},
  'MFloatArray': {'enums': {}, 'methods': {}, 'pymelEnums': {}},
  'MFloatMatrix': {'enums': {},
                   'methods': {'__add__': [{'argInfo': {'right': {'doc': 'Matrix to add.',
                                                                  'type': 'MFloatMatrix'}},
                                            'args': [('right',
                                                      'MFloatMatrix',
                                                      'in')],
                                            'defaults': {},
                                            'deprecated': False,
                                            'doc': 'The matrix addition operator.',
                                            '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': 'The matrix equality operator.',
                                           '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': 'Index 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'}}],
                               '__iadd__': [{'argInfo': {'right': {'doc': 'Matrix to add.',
                                                                   'type': 'MFloatMatrix'}},
                                             'args': [('right',
                                                       'MFloatMatrix',
                                                       'in')],
                                             'defaults': {},
                                             'deprecated': False,
                                             'doc': 'The in place matrix addition operator.',
                                             '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': 'The in place matrix multiplication operator.',
                                             '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': 'The in place matrix multiply by a scalar operator.',
                                             'inArgs': ['factor'],
                                             'outArgs': [],
                                             'returnInfo': {'doc': 'A reference to the result.',
                                                            'qualifiers': ['&'],
                                                            'type': 'MFloatMatrix'},
                                             'returnType': 'MFloatMatrix',
                                             'static': False,
                                             'typeQualifiers': {},
                                             'types': {'factor': 'float'}}],
                               '__isub__': [{'argInfo': {'right': {'doc': 'Matrix to subtract.',
                                                                   'type': 'MFloatMatrix'}},
                                             'args': [('right',
                                                       'MFloatMatrix',
                                                       'in')],
                                             'defaults': {},
                                             'deprecated': False,
                                             'doc': 'The in place matrix subtraction operator.',
                                             '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': 'The matrix multiplication operator.',
                                            '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': 'The matrix multiply by a scalar operator.',
                                            'inArgs': ['factor'],
                                            'outArgs': [],
                                            'returnInfo': {'doc': 'Scaled matrix.',
                                                           'qualifiers': [],
                                                           'type': 'MFloatMatrix'},
                                            'returnType': 'MFloatMatrix',
                                            'static': False,
                                            'typeQualifiers': {},
                                            'types': {'factor': 'float'}}],
                               '__ne__': [{'argInfo': {'other': {'doc': 'Matrix to test with.',
                                                                 'type': 'MFloatMatrix'}},
                                           'args': [('other',
                                                     'MFloatMatrix',
                                                     'in')],
                                           'defaults': {},
                                           'deprecated': False,
                                           'doc': 'The matrix inequality operator.',
                                           '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': 'The matrix subtraction operator.',
                                            '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': 'Compute and return the adjoint of this instance.',
                                            'inArgs': [],
                                            'outArgs': [],
                                            'returnInfo': {'doc': 'The adjoint of this matrix',
                                                           'qualifiers': [],
                                                           'type': 'MFloatMatrix'},
                                            'returnType': 'MFloatMatrix',
                                            'static': False,
                                            'typeQualifiers': {},
                                            'types': {}}],
                               'className': [{'argInfo': {},
                                              'args': [],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': 'Returns the name of this class.',
                                              'inArgs': [],
                                              'outArgs': [],
                                              'returnInfo': {'doc': 'The name of this class.',
                                                             'qualifiers': ['*'],
                                                             'type': 'char'},
                                              'returnType': 'char',
                                              'static': True,
                                              'typeQualifiers': {},
                                              'types': {}}],
                               'det3x3': [{'argInfo': {},
                                           'args': [],
                                           'defaults': {},
                                           'deprecated': False,
                                           'doc': 'Compute and return the determinant of the upper left 3x3 submatrix of this instance.',
                                           'inArgs': [],
                                           'outArgs': [],
                                           'returnInfo': {'doc': 'The determinant',
                                                          'qualifiers': [],
                                                          'type': 'float'},
                                           'returnType': 'float',
                                           'static': False,
                                           'typeQualifiers': {},
                                           'types': {}}],
                               'det4x4': [{'argInfo': {},
                                           'args': [],
                                           'defaults': {},
                                           'deprecated': False,
                                           'doc': 'Compute and return the determinant of this instance.',
                                           'inArgs': [],
                                           'outArgs': [],
                                           'returnInfo': {'doc': 'The determinant',
                                                          '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': 'Fill a 4x4 matrix of doubles with the elements from the instance.',
                                        'inArgs': [],
                                        'outArgs': ['dest'],
                                        'returnInfo': {'doc': '',
                                                       'qualifiers': [],
                                                       'type': None},
                                        'returnType': None,
                                        'static': False,
                                        'typeQualifiers': {},
                                        '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': 'Fill a 4x4 matrix of floats with the elements from the instance.',
                                        'inArgs': [],
                                        'outArgs': ['dest'],
                                        'returnInfo': {'doc': '',
                                                       'qualifiers': [],
                                                       'type': None},
                                        'returnType': None,
                                        'static': False,
                                        'typeQualifiers': {},
                                        'types': {'dest': 'float__array4'}}],
                               'homogenize': [{'argInfo': {},
                                               'args': [],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': 'Compute and return a homogenized version of this instance.',
                                               'inArgs': [],
                                               'outArgs': [],
                                               'returnInfo': {'doc': 'The homogenized matrix',
                                                              'qualifiers': [],
                                                              'type': 'MFloatMatrix'},
                                               'returnType': 'MFloatMatrix',
                                               'static': False,
                                               'typeQualifiers': {},
                                               'types': {}}],
                               'inverse': [{'argInfo': {},
                                            'args': [],
                                            'defaults': {},
                                            'deprecated': False,
                                            'doc': 'Compute and return the inverse of this instance.',
                                            'inArgs': [],
                                            'outArgs': [],
                                            'returnInfo': {'doc': 'The inverted matrix',
                                                           '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': 'Determine 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',
                                                                              '&']},
                                                 'types': {'other': 'MFloatMatrix',
                                                           'tolerance': 'float'}}],
                               'setToIdentity': [{'argInfo': {},
                                                  'args': [],
                                                  'defaults': {},
                                                  'deprecated': False,
                                                  'doc': 'Set this instance to the 4x4 identity matrix.',
                                                  'inArgs': [],
                                                  'outArgs': [],
                                                  'returnInfo': {'doc': 'A reference to this matrix.',
                                                                 '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': 'Set 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': 'Compute and return the transpose of this instance.',
                                              'inArgs': [],
                                              'outArgs': [],
                                              'returnInfo': {'doc': 'The transposed matrix',
                                                             'qualifiers': [],
                                                             'type': 'MFloatMatrix'},
                                              'returnType': 'MFloatMatrix',
                                              'static': False,
                                              'typeQualifiers': {},
                                              'types': {}}]},
                   'pymelEnums': {}},
  'MFloatPoint': {'enums': {},
                  'methods': {'__add__': [{'argInfo': {'other': {'doc': 'The vector to add.',
                                                                 'type': 'MFloatVector'}},
                                           'args': [('other',
                                                     'MFloatVector',
                                                     'in')],
                                           'defaults': {},
                                           'deprecated': False,
                                           'doc': 'The 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'}}],
                              '__eq__': [{'argInfo': {'other': {'doc': 'The point to compare with.',
                                                                'type': 'MFloatPoint'}},
                                          'args': [('other',
                                                    'MFloatPoint',
                                                    'in')],
                                          'defaults': {},
                                          'deprecated': False,
                                          'doc': 'The 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': 'The index operator.',
                                               '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': 'The 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': 'The 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': 'The 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': 'The 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': 'The 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': 'The 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': 'The 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': 'The 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': 'The 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': 'The 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': 'The 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': 'The 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': 'The 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': 'The 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': 'The 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': 'The 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'}}],
                              '__ne__': [{'argInfo': {'other': {'doc': 'The point to compare with.',
                                                                'type': 'MFloatPoint'}},
                                          'args': [('other',
                                                    'MFloatPoint',
                                                    'in')],
                                          'defaults': {},
                                          'deprecated': False,
                                          'doc': 'The 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': 'The 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': 'The 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'}}],
                              '__truediv__': [{'argInfo': {'scale': {'doc': 'The scale parameter.',
                                                                     'type': 'float'}},
                                               'args': [('scale',
                                                         'float',
                                                         'in')],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': 'The 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'}}],
                              'cartesianize': [{'argInfo': {},
                                                'args': [],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': 'If 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.',
                                                'inArgs': [],
                                                'outArgs': [],
                                                'returnInfo': {'doc': '',
                                                               'qualifiers': ['&'],
                                                               'type': 'MFloatPoint'},
                                                'returnType': 'MFloatPoint',
                                                'static': False,
                                                'typeQualifiers': {},
                                                'types': {}}],
                              'className': [{'argInfo': {},
                                             'args': [],
                                             'defaults': {},
                                             'deprecated': False,
                                             'doc': 'Returns the name of this class.',
                                             'inArgs': [],
                                             'outArgs': [],
                                             'returnInfo': {'doc': 'The name of this class.',
                                                            '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': 'Return 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': 'Copy 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': {},
                                       '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': 'Copy 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': {},
                                       'types': {'dest': 'float__array4'}}],
                              'homogenize': [{'argInfo': {},
                                              'args': [],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': 'If 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).',
                                              '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': 'Returns 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',
                                                                             '&']},
                                                'types': {'other': 'MFloatPoint',
                                                          'tol': 'float'}}],
                              'rationalize': [{'argInfo': {},
                                               'args': [],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': 'If 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.',
                                               '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': 'Copy 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': 'Copy 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': 'Copy 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': {}, 'methods': {}, 'pymelEnums': {}},
  'MFloatVector': {'enums': {},
                   'methods': {'__add__': [{'argInfo': {'other': {'doc': 'Vector to add.',
                                                                  'type': 'MFloatVector'}},
                                            'args': [('other',
                                                      'MFloatVector',
                                                      'in')],
                                            'defaults': {},
                                            'deprecated': False,
                                            'doc': 'The vector addition operator.',
                                            'inArgs': ['other'],
                                            'outArgs': [],
                                            'returnInfo': {'doc': 'The resulting vector.',
                                                           'qualifiers': [],
                                                           'type': 'MFloatVector'},
                                            'returnType': 'MFloatVector',
                                            'static': False,
                                            'typeQualifiers': {'other': ['const',
                                                                         '&']},
                                            'types': {'other': 'MFloatVector'}}],
                               '__eq__': [{'argInfo': {'other': {'doc': 'Vector to compare against.',
                                                                 'type': 'MFloatVector'}},
                                           'args': [('other',
                                                     'MFloatVector',
                                                     'in')],
                                           'defaults': {},
                                           'deprecated': False,
                                           'doc': 'The 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': 'The 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'}}],
                               '__iadd__': [{'argInfo': {'other': {'doc': 'Vector to add.',
                                                                   'type': 'MFloatVector'}},
                                             'args': [('other',
                                                       'MFloatVector',
                                                       'in')],
                                             'defaults': {},
                                             'deprecated': False,
                                             'doc': 'The 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'}}],
                               '__imul__': [{'argInfo': {'scalar': {'doc': 'Scale factor.',
                                                                    'type': 'int'}},
                                             'args': [('scalar', 'int', 'in')],
                                             'defaults': {},
                                             'deprecated': False,
                                             'doc': 'The in place multiplication operator.',
                                             'inArgs': ['scalar'],
                                             'outArgs': [],
                                             'returnInfo': {'doc': 'A reference to the scaled vector.',
                                                            'qualifiers': ['&'],
                                                            'type': 'MFloatVector'},
                                             'returnType': 'MFloatVector',
                                             'static': False,
                                             'typeQualifiers': {},
                                             'types': {'scalar': 'int'}},
                                            {'argInfo': {'scalar': {'doc': 'Scale factor.',
                                                                    'type': 'short'}},
                                             'args': [('scalar',
                                                       'short',
                                                       'in')],
                                             'defaults': {},
                                             'deprecated': False,
                                             'doc': 'The in place multiplication operator.',
                                             'inArgs': ['scalar'],
                                             'outArgs': [],
                                             'returnInfo': {'doc': 'A reference to the scaled vector.',
                                                            'qualifiers': ['&'],
                                                            'type': 'MFloatVector'},
                                             'returnType': 'MFloatVector',
                                             'static': False,
                                             'typeQualifiers': {},
                                             'types': {'scalar': 'short'}},
                                            {'argInfo': {'scalar': {'doc': 'Scale factor.',
                                                                    'type': 'uint'}},
                                             'args': [('scalar', 'uint', 'in')],
                                             'defaults': {},
                                             'deprecated': False,
                                             'doc': 'The 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': 'The 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': 'The in place multiplication operator.',
                                             'inArgs': ['scalar'],
                                             'outArgs': [],
                                             'returnInfo': {'doc': 'A reference to the scaled vector.',
                                                            'qualifiers': ['&'],
                                                            'type': 'MFloatVector'},
                                             'returnType': 'MFloatVector',
                                             'static': False,
                                             'typeQualifiers': {},
                                             'types': {'scalar': 'float'}},
                                            {'argInfo': {'scalar': {'doc': 'Scale factor.',
                                                                    'type': 'double'}},
                                             'args': [('scalar',
                                                       'double',
                                                       'in')],
                                             'defaults': {},
                                             'deprecated': False,
                                             'doc': 'The in place multiplication operator.',
                                             'inArgs': ['scalar'],
                                             'outArgs': [],
                                             'returnInfo': {'doc': 'A reference to the scaled vector.',
                                                            'qualifiers': ['&'],
                                                            'type': 'MFloatVector'},
                                             'returnType': 'MFloatVector',
                                             'static': False,
                                             'typeQualifiers': {},
                                             'types': {'scalar': 'double'}},
                                            {'argInfo': {'right': {'doc': '',
                                                                   'type': 'MFloatMatrix'}},
                                             'args': [('right',
                                                       'MFloatMatrix',
                                                       'in')],
                                             'defaults': {},
                                             'deprecated': False,
                                             'doc': 'The in place matrix multiplication operator.',
                                             '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': 'The 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'}}],
                               '__itruediv__': [{'argInfo': {'scalar': {'doc': 'Division factor.',
                                                                        'type': 'float'}},
                                                 'args': [('scalar',
                                                           'float',
                                                           'in')],
                                                 'defaults': {},
                                                 'deprecated': False,
                                                 'doc': 'The in place division operator.',
                                                 'inArgs': ['scalar'],
                                                 'outArgs': [],
                                                 'returnInfo': {'doc': 'A reference to the scaled vector.',
                                                                'qualifiers': ['&'],
                                                                'type': 'MFloatVector'},
                                                 'returnType': 'MFloatVector',
                                                 'static': False,
                                                 'typeQualifiers': {},
                                                 'types': {'scalar': 'float'}}],
                               '__mul__': [{'argInfo': {'scalar': {'doc': 'Scale factor.',
                                                                   'type': 'int'}},
                                            'args': [('scalar', 'int', 'in')],
                                            'defaults': {},
                                            'deprecated': False,
                                            'doc': 'The multiplication operator.',
                                            'inArgs': ['scalar'],
                                            'outArgs': [],
                                            'returnInfo': {'doc': 'The scaled vector.',
                                                           'qualifiers': [],
                                                           'type': 'MFloatVector'},
                                            'returnType': 'MFloatVector',
                                            'static': False,
                                            'typeQualifiers': {},
                                            'types': {'scalar': 'int'}},
                                           {'argInfo': {'scalar': {'doc': 'Scale factor.',
                                                                   'type': 'short'}},
                                            'args': [('scalar', 'short', 'in')],
                                            'defaults': {},
                                            'deprecated': False,
                                            'doc': 'The multiplication operator.',
                                            'inArgs': ['scalar'],
                                            'outArgs': [],
                                            'returnInfo': {'doc': 'The scaled vector.',
                                                           'qualifiers': [],
                                                           'type': 'MFloatVector'},
                                            'returnType': 'MFloatVector',
                                            'static': False,
                                            'typeQualifiers': {},
                                            'types': {'scalar': 'short'}},
                                           {'argInfo': {'scalar': {'doc': 'Scale factor.',
                                                                   'type': 'uint'}},
                                            'args': [('scalar', 'uint', 'in')],
                                            'defaults': {},
                                            'deprecated': False,
                                            'doc': 'The 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': 'The 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': 'The multiplication operator.',
                                            'inArgs': ['scalar'],
                                            'outArgs': [],
                                            'returnInfo': {'doc': 'The scaled vector.',
                                                           'qualifiers': [],
                                                           'type': 'MFloatVector'},
                                            'returnType': 'MFloatVector',
                                            'static': False,
                                            'typeQualifiers': {},
                                            'types': {'scalar': 'float'}},
                                           {'argInfo': {'scalar': {'doc': 'Scale factor.',
                                                                   'type': 'double'}},
                                            'args': [('scalar',
                                                      'double',
                                                      'in')],
                                            'defaults': {},
                                            'deprecated': False,
                                            'doc': 'The multiplication operator.',
                                            'inArgs': ['scalar'],
                                            'outArgs': [],
                                            'returnInfo': {'doc': 'The scaled vector.',
                                                           'qualifiers': [],
                                                           'type': 'MFloatVector'},
                                            'returnType': 'MFloatVector',
                                            'static': False,
                                            'typeQualifiers': {},
                                            'types': {'scalar': 'double'}},
                                           {'argInfo': {'right': {'doc': '',
                                                                  'type': 'MFloatMatrix'}},
                                            'args': [('right',
                                                      'MFloatMatrix',
                                                      'in')],
                                            'defaults': {},
                                            'deprecated': False,
                                            'doc': 'The matrix multiplication operator.',
                                            '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': 'The dot product operator.',
                                            'inArgs': ['right'],
                                            'outArgs': [],
                                            'returnInfo': {'doc': 'Dot product value.',
                                                           'qualifiers': [],
                                                           'type': 'float'},
                                            'returnType': 'float',
                                            'static': False,
                                            'typeQualifiers': {'right': ['const',
                                                                         '&']},
                                            'types': {'right': 'MFloatVector'}}],
                               '__ne__': [{'argInfo': {'other': {'doc': 'Vector to compare against.',
                                                                 'type': 'MFloatVector'}},
                                           'args': [('other',
                                                     'MFloatVector',
                                                     'in')],
                                           'defaults': {},
                                           'deprecated': False,
                                           'doc': 'The 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': 'The unary minus operator. Negates the value of each of the x, y, and z components of the vector.',
                                            'inArgs': [],
                                            'outArgs': [],
                                            'returnInfo': {'doc': 'The resulting vector.',
                                                           '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': 'The vector subtraction operator.',
                                            'inArgs': ['other'],
                                            'outArgs': [],
                                            'returnInfo': {'doc': 'The resulting vector.',
                                                           'qualifiers': [],
                                                           'type': 'MFloatVector'},
                                            'returnType': 'MFloatVector',
                                            'static': False,
                                            'typeQualifiers': {'other': ['const',
                                                                         '&']},
                                            'types': {'other': 'MFloatVector'}}],
                               '__truediv__': [{'argInfo': {'scalar': {'doc': 'Division factor.',
                                                                       'type': 'float'}},
                                                'args': [('scalar',
                                                          'float',
                                                          'in')],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': 'The division operator.',
                                                'inArgs': ['scalar'],
                                                'outArgs': [],
                                                'returnInfo': {'doc': 'The scaled vector.',
                                                               'qualifiers': [],
                                                               'type': 'MFloatVector'},
                                                'returnType': 'MFloatVector',
                                                'static': False,
                                                'typeQualifiers': {},
                                                'types': {'scalar': 'float'}}],
                               'angle': [{'argInfo': {'other': {'doc': 'the vector from which to compute the angle.',
                                                                'type': 'MFloatVector'}},
                                          'args': [('other',
                                                    'MFloatVector',
                                                    'in')],
                                          'defaults': {},
                                          'deprecated': False,
                                          'doc': 'Returns 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': 'Extracts 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': {},
                                        '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': 'Returns 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',
                                                                              '&']},
                                                 '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': 'Returns 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',
                                                                            '&']},
                                               'types': {'other': 'MFloatVector',
                                                         'tol': 'float'}}],
                               'length': [{'argInfo': {},
                                           'args': [],
                                           'defaults': {},
                                           'deprecated': False,
                                           'doc': 'The length of the vector.',
                                           'inArgs': [],
                                           'outArgs': [],
                                           'returnInfo': {'doc': 'The length of the vector.',
                                                          'qualifiers': [],
                                                          'type': 'float'},
                                           'returnType': 'float',
                                           'static': False,
                                           'typeQualifiers': {},
                                           'types': {}}],
                               'normal': [{'argInfo': {},
                                           'args': [],
                                           'defaults': {},
                                           'deprecated': False,
                                           'doc': 'Computes a unit vector aligned to the vector.',
                                           'inArgs': [],
                                           'outArgs': [],
                                           'returnInfo': {'doc': 'The unit vector.',
                                                          'qualifiers': [],
                                                          'type': 'MFloatVector'},
                                           'returnType': 'MFloatVector',
                                           'static': False,
                                           'typeQualifiers': {},
                                           'types': {}}],
                               'normalize': [{'argInfo': {},
                                              'args': [],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': 'Performs an in place normalization of the vector',
                                              'inArgs': [],
                                              'outArgs': [],
                                              'returnInfo': {'doc': '',
                                                             'qualifiers': [],
                                                             'type': None},
                                              'returnType': None,
                                              'static': False,
                                              'typeQualifiers': {},
                                              'types': {}}]},
                   'pymelEnums': {}},
  'MFloatVectorArray': {'enums': {}, 'methods': {}, 'pymelEnums': {}},
  'MFn': {'enums': {'Type': {'valueDocs': {'NLE': 'NLE node.',
                                           'UVPin': 'Not fully implemented; Do not use.',
                                           'adskMaterial': 'Consistent material asset from an Autodesk Material Library.',
                                           'assembly': 'Base class for scene assembly nodes.',
                                           'attribute2Long': 'Used for backward compatibility.',
                                           'attribute3Long': 'Used for backward compatibility.',
                                           'colorMgtGlobals': 'Color management globals node.',
                                           'colorProfile': 'Color Profile Node.',
                                           'containerBase': 'base class for containers',
                                           'creaseSet': 'Crease Set Node.',
                                           'dagContainer': 'dag container node',
                                           'data2Long': 'Used for backward compatibility.',
                                           'data3Long': 'Used for backward compatibility.',
                                           'editMetadata': 'editMetadata Node',
                                           'kAdskMaterial': 'Consistent material asset from an Autodesk Material Library.',
                                           'kAssembly': 'Base class for scene assembly nodes.',
                                           'kAttribute2Long': 'Used for backward compatibility.',
                                           'kAttribute3Long': 'Used for backward compatibility.',
                                           'kColorMgtGlobals': 'Color management globals node.',
                                           'kColorProfile': 'Color Profile Node.',
                                           'kContainerBase': 'base class for containers',
                                           'kCreaseSet': 'Crease Set Node.',
                                           'kDagContainer': 'dag container node',
                                           'kData2Long': 'Used for backward compatibility.',
                                           'kData3Long': 'Used for backward compatibility.',
                                           'kEditMetadata': 'editMetadata Node',
                                           'kKeyframeDeltaScale': 'DeprecatedNot used. Maya instead uses kKeyframeDeltaMove and kKeyframe events.',
                                           'kLast': 'Defines the last entry.',
                                           'kNLE': 'NLE node.',
                                           'kPlugin': 'Custom Plug-in.',
                                           'kPluginBlendShape': 'Custom deformer node derived from MPxBlendShape.',
                                           'kPluginCameraSet': 'Custom cameraSet nodes (dependency nodes) derived from MPxCameraSet.',
                                           'kPluginConstraintNode': 'Custom constraint node derived from MPxConstraint.',
                                           'kPluginData': 'Custom data types derived from MPxData.',
                                           'kPluginDeformerNode': 'Custom deformer node derived from MPxDeformerNode.',
                                           'kPluginDependNode': 'Custom dependency nodes derived from MPxNode.',
                                           'kPluginEmitterNode': 'Custom dependency graph node representing an emitter derived from MPxEmitterNode.',
                                           'kPluginFieldNode': 'Custom dependency graph node representing a field derived from MPxFieldNode.',
                                           'kPluginGeometryData': 'Custom container for arbitrary Geometry type derived from MPxGeometryData.',
                                           'kPluginGeometryFilter': 'Custom deformer node derived from MPxGeometryFilter.',
                                           'kPluginHardwareShader': 'Custom hardware shader derived from MPxHardwareShader.',
                                           'kPluginHwShaderNode': 'Custom hardware shader derived from MPxHwShaderNode (old implementation)',
                                           'kPluginIkSolver': 'Custom IK Solvers derived from MPxIkSolverNode.',
                                           'kPluginImagePlaneNode': 'Custom Image Plane classes derived from MPxImagePlane.',
                                           'kPluginLocatorNode': 'Custom locator node derived from MPxLocatorNode.',
                                           'kPluginManipContainer': 'Custom manipulator containers derived from MPxManipContainer.',
                                           'kPluginManipulatorNode': 'Custom manipulator node derived from MPxManipulatorNode.',
                                           'kPluginMotionPathNode': 'Custom motionPath nodes derived from MPxMotionPathNode.',
                                           'kPluginObjectSet': 'Custom sets (dependency nodes) derived from MPxObjectSet.',
                                           'kPluginShape': 'Custom shapes (dependency nodes) derived from MPxSurfaceShape.',
                                           'kPluginSkinCluster': 'Custom deformer node derived from MPxSkinCluster.',
                                           'kPluginSpringNode': 'Custom dependency graph node representing a spring derived from MPxSpringNode.',
                                           'kPluginTransformNode': 'Custom transform node derived from MPxTransform.',
                                           'kPolyCBoolOp': 'Carve Booleans Node.',
                                           'kPolyEditEdgeFlow': 'Edit Edge Flow History Node.',
                                           'kProximityPin': 'Not fully implemented; Do not use.',
                                           'kStereoCameraMaster': 'Master node for a stereo camera rig.',
                                           'kToolContext': 'Tool context.',
                                           'kUVPin': 'Not fully implemented; Do not use.',
                                           'keyframeDeltaScale': 'DeprecatedNot used. Maya instead uses kKeyframeDeltaMove and kKeyframe events.',
                                           'last': 'Defines the last entry.',
                                           'plugin': 'Custom Plug-in.',
                                           'pluginBlendShape': 'Custom deformer node derived from MPxBlendShape.',
                                           'pluginCameraSet': 'Custom cameraSet nodes (dependency nodes) derived from MPxCameraSet.',
                                           'pluginConstraintNode': 'Custom constraint node derived from MPxConstraint.',
                                           'pluginData': 'Custom data types derived from MPxData.',
                                           'pluginDeformerNode': 'Custom deformer node derived from MPxDeformerNode.',
                                           'pluginDependNode': 'Custom dependency nodes derived from MPxNode.',
                                           'pluginEmitterNode': 'Custom dependency graph node representing an emitter derived from MPxEmitterNode.',
                                           'pluginFieldNode': 'Custom dependency graph node representing a field derived from MPxFieldNode.',
                                           'pluginGeometryData': 'Custom container for arbitrary Geometry type derived from MPxGeometryData.',
                                           'pluginGeometryFilter': 'Custom deformer node derived from MPxGeometryFilter.',
                                           'pluginHardwareShader': 'Custom hardware shader derived from MPxHardwareShader.',
                                           'pluginHwShaderNode': 'Custom hardware shader derived from MPxHwShaderNode (old implementation)',
                                           'pluginIkSolver': 'Custom IK Solvers derived from MPxIkSolverNode.',
                                           'pluginImagePlaneNode': 'Custom Image Plane classes derived from MPxImagePlane.',
                                           'pluginLocatorNode': 'Custom locator node derived from MPxLocatorNode.',
                                           'pluginManipContainer': 'Custom manipulator containers derived from MPxManipContainer.',
                                           'pluginManipulatorNode': 'Custom manipulator node derived from MPxManipulatorNode.',
                                           'pluginMotionPathNode': 'Custom motionPath nodes derived from MPxMotionPathNode.',
                                           'pluginObjectSet': 'Custom sets (dependency nodes) derived from MPxObjectSet.',
                                           'pluginShape': 'Custom shapes (dependency nodes) derived from MPxSurfaceShape.',
                                           'pluginSkinCluster': 'Custom deformer node derived from MPxSkinCluster.',
                                           'pluginSpringNode': 'Custom dependency graph node representing a spring derived from MPxSpringNode.',
                                           'pluginTransformNode': 'Custom transform node derived from MPxTransform.',
                                           'polyCBoolOp': 'Carve Booleans Node.',
                                           'polyEditEdgeFlow': 'Edit Edge Flow History Node.',
                                           'proximityPin': 'Not fully implemented; Do not use.',
                                           'stereoCameraMaster': 'Master node for a stereo camera rig.',
                                           'toolContext': 'Tool context.'},
                             '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), ('kMorph', 352), ('kSolidify', 353), ('kProximityWrap', 354), ('kWire', 355), ('kGroupId', 356), ('kGroupParts', 357), ('kGuide', 358), ('kHsvToRgb', 359), ('kHyperGraphInfo', 360), ('kHyperLayout', 361), ('kHyperView', 362), ('kIkSolver', 363), ('kMCsolver', 364), ('kPASolver', 365), ('kSCsolver', 366), ('kRPsolver', 367), ('kSplineSolver', 368), ('kIkSystem', 369), ('kImagePlane', 370), ('kLambert', 371), ('kReflect', 372), ('kBlinn', 373), ('kPhong', 374), ('kPhongExplorer', 375), ('kLayeredShader', 376), ('kStandardSurface', 377), ('kLightInfo', 378), ('kLeastSquares', 379), ('kLightFogMaterial', 380), ('kEnvFogMaterial', 381), ('kLightList', 382), ('kLightSource', 383), ('kLuminance', 384), ('kMakeGroup', 385), ('kMaterial', 386), ('kDiffuseMaterial', 387), ('kLambertMaterial', 388), ('kBlinnMaterial', 389), ('kPhongMaterial', 390), ('kLightSourceMaterial', 391), ('kMaterialInfo', 392), ('kMaterialTemplate', 393), ('kMatrixAdd', 394), ('kMatrixHold', 395), ('kMatrixMult', 396), ('kMatrixPass', 397), ('kMatrixWtAdd', 398), ('kMidModifier', 399), ('kMidModifierWithMatrix', 400), ('kPolyBevel', 401), ('kPolyTweak', 402), ('kPolyAppend', 403), ('kPolyChipOff', 404), ('kPolyCloseBorder', 405), ('kPolyCollapseEdge', 406), ('kPolyCollapseF', 407), ('kPolyCylProj', 408), ('kPolyDelEdge', 409), ('kPolyDelFacet', 410), ('kPolyDelVertex', 411), ('kPolyExtrudeFacet', 412), ('kPolyMapCut', 413), ('kPolyMapDel', 414), ('kPolyMapSew', 415), ('kPolyMergeEdge', 416), ('kPolyMergeFacet', 417), ('kPolyMoveEdge', 418), ('kPolyMoveFacet', 419), ('kPolyMoveFacetUV', 420), ('kPolyMoveUV', 421), ('kPolyMoveVertex', 422), ('kPolyMoveVertexUV', 423), ('kPolyNormal', 424), ('kPolyPlanProj', 425), ('kPolyProj', 426), ('kPolyQuad', 427), ('kPolySmooth', 428), ('kPolySoftEdge', 429), ('kPolySphProj', 430), ('kPolySplit', 431), ('kPolySubdEdge', 432), ('kPolySubdFacet', 433), ('kPolyTriangulate', 434), ('kPolyCreator', 435), ('kPolyPrimitive', 436), ('kPolyCone', 437), ('kPolyCube', 438), ('kPolyCylinder', 439), ('kPolyMesh', 440), ('kPolySphere', 441), ('kPolyTorus', 442), ('kPolyCreateFacet', 443), ('kPolyUnite', 444), ('kMotionPath', 445), ('kPluginMotionPathNode', 446), ('kMultilisterLight', 447), ('kMultiplyDivide', 448), ('kOldGeometryConstraint', 449), ('kOpticalFX', 450), ('kParticleAgeMapper', 451), ('kParticleCloud', 452), ('kParticleColorMapper', 453), ('kParticleIncandecenceMapper', 454), ('kParticleTransparencyMapper', 455), ('kPartition', 456), ('kPlace2dTexture', 457), ('kPlace3dTexture', 458), ('kPluginDependNode', 459), ('kPluginLocatorNode', 460), ('kPlusMinusAverage', 461), ('kPointMatrixMult', 462), ('kPolySeparate', 463), ('kPostProcessList', 464), ('kProjection', 465), ('kRecord', 466), ('kRenderUtilityList', 467), ('kReverse', 468), ('kRgbToHsv', 469), ('kRigidSolver', 470), ('kSet', 471), ('kTextureBakeSet', 472), ('kVertexBakeSet', 473), ('kSetRange', 474), ('kShaderGlow', 475), ('kShaderList', 476), ('kShadingMap', 477), ('kSamplerInfo', 478), ('kShapeFragment', 479), ('kSimpleVolumeShader', 480), ('kSl60', 481), ('kSnapshot', 482), ('kStoryBoard', 483), ('kSummaryObject', 484), ('kSuper', 485), ('kControl', 486), ('kSurfaceLuminance', 487), ('kSurfaceShader', 488), ('kTextureList', 489), ('kTextureEnv', 490), ('kEnvBall', 491), ('kEnvCube', 492), ('kEnvChrome', 493), ('kEnvSky', 494), ('kEnvSphere', 495), ('kTexture2d', 496), ('kBulge', 497), ('kChecker', 498), ('kCloth', 499), ('kFileTexture', 500), ('kFractal', 501), ('kGrid', 502), ('kMountain', 503), ('kRamp', 504), ('kStencil', 505), ('kWater', 506), ('kTexture3d', 507), ('kBrownian', 508), ('kCloud', 509), ('kCrater', 510), ('kGranite', 511), ('kLeather', 512), ('kMarble', 513), ('kRock', 514), ('kSnow', 515), ('kSolidFractal', 516), ('kStucco', 517), ('kTxSl', 518), ('kWood', 519), ('kTime', 520), ('kTimeToUnitConversion', 521), ('kRenderSetup', 522), ('kRenderGlobals', 523), ('kRenderGlobalsList', 524), ('kRenderQuality', 525), ('kResolution', 526), ('kHardwareRenderGlobals', 527), ('kArrayMapper', 528), ('kUnitConversion', 529), ('kUnitToTimeConversion', 530), ('kUseBackground', 531), ('kUnknown', 532), ('kVectorProduct', 533), ('kVolumeShader', 534), ('kComponent', 535), ('kCurveCVComponent', 536), ('kCurveEPComponent', 537), ('kCurveKnotComponent', 538), ('kCurveParamComponent', 539), ('kIsoparmComponent', 540), ('kPivotComponent', 541), ('kSurfaceCVComponent', 542), ('kSurfaceEPComponent', 543), ('kSurfaceKnotComponent', 544), ('kEdgeComponent', 545), ('kLatticeComponent', 546), ('kSurfaceRangeComponent', 547), ('kDecayRegionCapComponent', 548), ('kDecayRegionComponent', 549), ('kMeshComponent', 550), ('kMeshEdgeComponent', 551), ('kMeshPolygonComponent', 552), ('kMeshFrEdgeComponent', 553), ('kMeshVertComponent', 554), ('kMeshFaceVertComponent', 555), ('kOrientationComponent', 556), ('kSubVertexComponent', 557), ('kMultiSubVertexComponent', 558), ('kSetGroupComponent', 559), ('kDynParticleSetComponent', 560), ('kSelectionItem', 561), ('kDagSelectionItem', 562), ('kNonDagSelectionItem', 563), ('kItemList', 564), ('kAttribute', 565), ('kNumericAttribute', 566), ('kDoubleAngleAttribute', 567), ('kFloatAngleAttribute', 568), ('kDoubleLinearAttribute', 569), ('kFloatLinearAttribute', 570), ('kTimeAttribute', 571), ('kEnumAttribute', 572), ('kUnitAttribute', 573), ('kTypedAttribute', 574), ('kCompoundAttribute', 575), ('kGenericAttribute', 576), ('kLightDataAttribute', 577), ('kMatrixAttribute', 578), ('kFloatMatrixAttribute', 579), ('kMessageAttribute', 580), ('kPlugin', 581), ('kData', 582), ('kComponentListData', 583), ('kDoubleArrayData', 584), ('kIntArrayData', 585), ('kUintArrayData', 586), ('kLatticeData', 587), ('kMatrixData', 588), ('kMeshData', 589), ('kNurbsSurfaceData', 590), ('kNurbsCurveData', 591), ('kNumericData', 592), ('kData2Double', 593), ('kData2Float', 594), ('kData2Int', 595), ('kData2Long', 595), ('kData2Short', 596), ('kData3Double', 597), ('kData3Float', 598), ('kData3Int', 599), ('kData3Long', 599), ('kData3Short', 600), ('kPluginData', 601), ('kPointArrayData', 602), ('kMatrixArrayData', 603), ('kSphereData', 604), ('kStringData', 605), ('kStringArrayData', 606), ('kVectorArrayData', 607), ('kSelectionList', 608), ('kTransformGeometry', 609), ('kCommEdgePtManip', 610), ('kCommEdgeOperManip', 611), ('kCommEdgeSegmentManip', 612), ('kCommCornerManip', 613), ('kCommCornerOperManip', 614), ('kPluginDeformerNode', 615), ('kTorus', 616), ('kPolyBoolOp', 617), ('kSingleShadingSwitch', 618), ('kDoubleShadingSwitch', 619), ('kTripleShadingSwitch', 620), ('kNurbsSquare', 621), ('kAnisotropy', 622), ('kNonLinear', 623), ('kDeformFunc', 624), ('kDeformBend', 625), ('kDeformTwist', 626), ('kDeformSquash', 627), ('kDeformFlare', 628), ('kDeformSine', 629), ('kDeformWave', 630), ('kDeformBendManip', 631), ('kDeformTwistManip', 632), ('kDeformSquashManip', 633), ('kDeformFlareManip', 634), ('kDeformSineManip', 635), ('kDeformWaveManip', 636), ('kSoftModManip', 637), ('kDistanceManip', 638), ('kScript', 639), ('kCurveFromMeshEdge', 640), ('kCurveCurveIntersect', 641), ('kNurbsCircular3PtArc', 642), ('kNurbsCircular2PtArc', 643), ('kOffsetSurface', 644), ('kRoundConstantRadius', 645), ('kRoundRadiusManip', 646), ('kRoundRadiusCrvManip', 647), ('kRoundConstantRadiusManip', 648), ('kThreePointArcManip', 649), ('kTwoPointArcManip', 650), ('kTextButtonManip', 651), ('kOffsetSurfaceManip', 652), ('kImageData', 653), ('kImageLoad', 654), ('kImageSave', 655), ('kImageNetSrc', 656), ('kImageNetDest', 657), ('kImageRender', 658), ('kImageAdd', 659), ('kImageDiff', 660), ('kImageMultiply', 661), ('kImageOver', 662), ('kImageUnder', 663), ('kImageColorCorrect', 664), ('kImageBlur', 665), ('kImageFilter', 666), ('kImageDepth', 667), ('kImageDisplay', 668), ('kImageView', 669), ('kImageMotionBlur', 670), ('kViewColorManager', 671), ('kMatrixFloatData', 672), ('kSkinShader', 673), ('kComponentManip', 674), ('kSelectionListData', 675), ('kObjectFilter', 676), ('kObjectMultiFilter', 677), ('kObjectNameFilter', 678), ('kObjectTypeFilter', 679), ('kObjectAttrFilter', 680), ('kObjectRenderFilter', 681), ('kObjectScriptFilter', 682), ('kSelectionListOperator', 683), ('kSubdiv', 684), ('kPolyToSubdiv', 685), ('kSkinClusterFilter', 686), ('kKeyingGroup', 687), ('kCharacter', 688), ('kCharacterOffset', 689), ('kDagPose', 690), ('kStitchAsNurbsShell', 691), ('kExplodeNurbsShell', 692), ('kNurbsBoolean', 693), ('kStitchSrfManip', 694), ('kForceUpdateManip', 695), ('kPluginManipContainer', 696), ('kPolySewEdge', 697), ('kPolyMergeVert', 698), ('kPolySmoothFacet', 699), ('kSmoothCurve', 700), ('kGlobalStitch', 701), ('kSubdivCVComponent', 702), ('kSubdivEdgeComponent', 703), ('kSubdivFaceComponent', 704), ('kUVManip2D', 705), ('kTranslateUVManip2D', 706), ('kRotateUVManip2D', 707), ('kScaleUVManip2D', 708), ('kPolyTweakUV', 709), ('kMoveUVShellManip2D', 710), ('kPluginShape', 711), ('kGeometryData', 712), ('kSingleIndexedComponent', 713), ('kDoubleIndexedComponent', 714), ('kTripleIndexedComponent', 715), ('kExtendSurfaceDistanceManip', 716), ('kSquareSrf', 717), ('kSquareSrfManip', 718), ('kSubdivToPoly', 719), ('kDynBase', 720), ('kDynEmitterManip', 721), ('kDynFieldsManip', 722), ('kDynBaseFieldManip', 723), ('kDynAirManip', 724), ('kDynNewtonManip', 725), ('kDynTurbulenceManip', 726), ('kDynSpreadManip', 727), ('kDynAttenuationManip', 728), ('kDynArrayAttrsData', 729), ('kPluginFieldNode', 730), ('kPluginEmitterNode', 731), ('kPluginSpringNode', 732), ('kDisplayLayer', 733), ('kDisplayLayerManager', 734), ('kPolyColorPerVertex', 735), ('kCreateColorSet', 736), ('kDeleteColorSet', 737), ('kCopyColorSet', 738), ('kBlendColorSet', 739), ('kPolyColorMod', 740), ('kPolyColorDel', 741), ('kCharacterMappingData', 742), ('kDynSweptGeometryData', 743), ('kWrapFilter', 744), ('kMeshVtxFaceComponent', 745), ('kBinaryData', 746), ('kAttribute2Double', 747), ('kAttribute2Float', 748), ('kAttribute2Short', 749), ('kAttribute2Int', 750), ('kAttribute2Long', 750), ('kAttribute3Double', 751), ('kAttribute3Float', 752), ('kAttribute3Short', 753), ('kAttribute3Int', 754), ('kAttribute3Long', 754), ('kReference', 755), ('kBlindData', 756), ('kBlindDataTemplate', 757), ('kPolyBlindData', 758), ('kPolyNormalPerVertex', 759), ('kNurbsToSubdiv', 760), ('kPluginIkSolver', 761), ('kInstancer', 762), ('kMoveVertexManip', 763), ('kStroke', 764), ('kBrush', 765), ('kStrokeGlobals', 766), ('kPluginGeometryData', 767), ('kLightLink', 768), ('kDynGlobals', 769), ('kPolyReduce', 770), ('kLodThresholds', 771), ('kChooser', 772), ('kLodGroup', 773), ('kMultDoubleLinear', 774), ('kFourByFourMatrix', 775), ('kTowPointOnSurfaceManip', 776), ('kSurfaceEdManip', 777), ('kSurfaceFaceComponent', 778), ('kClipScheduler', 779), ('kClipLibrary', 780), ('kSubSurface', 781), ('kSmoothTangentSrf', 782), ('kRenderPass', 783), ('kRenderPassSet', 784), ('kRenderLayer', 785), ('kRenderLayerManager', 786), ('kPassContributionMap', 787), ('kPrecompExport', 788), ('kRenderTarget', 789), ('kRenderedImageSource', 790), ('kImageSource', 791), ('kPolyFlipEdge', 792), ('kPolyExtrudeEdge', 793), ('kAnimBlend', 794), ('kAnimBlendInOut', 795), ('kPolyAppendVertex', 796), ('kUvChooser', 797), ('kSubdivCompId', 798), ('kVolumeAxis', 799), ('kDeleteUVSet', 800), ('kSubdHierBlind', 801), ('kSubdBlindData', 802), ('kCharacterMap', 803), ('kLayeredTexture', 804), ('kSubdivCollapse', 805), ('kParticleSamplerInfo', 806), ('kCopyUVSet', 807), ('kCreateUVSet', 808), ('kClip', 809), ('kPolySplitVert', 810), ('kSubdivData', 811), ('kSubdivGeom', 812), ('kUInt64ArrayData', 813), ('kInt64ArrayData', 814), ('kPolySplitEdge', 815), ('kSubdivReverseFaces', 816), ('kMeshMapComponent', 817), ('kSectionManip', 818), ('kXsectionSubdivEdit', 819), ('kSubdivToNurbs', 820), ('kEditCurve', 821), ('kEditCurveManip', 822), ('kCrossSectionManager', 823), ('kCreateSectionManip', 824), ('kCrossSectionEditManip', 825), ('kDropOffFunction', 826), ('kSubdBoolean', 827), ('kSubdModifyEdge', 828), ('kModifyEdgeCrvManip', 829), ('kModifyEdgeManip', 830), ('kScalePointManip', 831), ('kTransformBoxManip', 832), ('kSymmetryLocator', 833), ('kSymmetryMapVector', 834), ('kSymmetryMapCurve', 835), ('kCurveFromSubdivEdge', 836), ('kCreateBPManip', 837), ('kModifyEdgeBaseManip', 838), ('kSubdExtrudeFace', 839), ('kSubdivSurfaceVarGroup', 840), ('kSfRevolveManip', 841), ('kCurveFromSubdivFace', 842), ('kUnused1', 843), ('kUnused2', 844), ('kUnused3', 845), ('kUnused4', 846), ('kUnused5', 847), ('kUnused6', 848), ('kPolyTransfer', 849), ('kPolyAverageVertex', 850), ('kPolyAutoProj', 851), ('kPolyLayoutUV', 852), ('kPolyMapSewMove', 853), ('kSubdModifier', 854), ('kSubdMoveVertex', 855), ('kSubdMoveEdge', 856), ('kSubdMoveFace', 857), ('kSubdDelFace', 858), ('kSnapshotShape', 859), ('kSubdivMapComponent', 860), ('kJiggleDeformer', 861), ('kGlobalCacheControls', 862), ('kDiskCache', 863), ('kSubdCloseBorder', 864), ('kSubdMergeVert', 865), ('kBoxData', 866), ('kBox', 867), ('kRenderBox', 868), ('kSubdSplitFace', 869), ('kVolumeFog', 870), ('kSubdTweakUV', 871), ('kSubdMapCut', 872), ('kSubdLayoutUV', 873), ('kSubdMapSewMove', 874), ('kOcean', 875), ('kVolumeNoise', 876), ('kSubdAutoProj', 877), ('kSubdSubdivideFace', 878), ('kNoise', 879), ('kAttribute4Double', 880), ('kData4Double', 881), ('kSubdPlanProj', 882), ('kSubdTweak', 883), ('kSubdProjectionManip', 884), ('kSubdMappingManip', 885), ('kHardwareReflectionMap', 886), ('kPolyNormalizeUV', 887), ('kPolyFlipUV', 888), ('kHwShaderNode', 889), ('kPluginHardwareShader', 890), ('kPluginHwShaderNode', 891), ('kSubdAddTopology', 892), ('kSubdCleanTopology', 893), ('kImplicitCone', 894), ('kImplicitSphere', 895), ('kRampShader', 896), ('kVolumeLight', 897), ('kOceanShader', 898), ('kBevelPlus', 899), ('kStyleCurve', 900), ('kPolyCut', 901), ('kPolyPoke', 902), ('kPolyWedgeFace', 903), ('kPolyCutManipContainer', 904), ('kPolyCutManip', 905), ('kPolyMirrorManipContainer', 906), ('kPolyPokeManip', 907), ('kFluidTexture3D', 908), ('kFluidTexture2D', 909), ('kPolyMergeUV', 910), ('kPolyStraightenUVBorder', 911), ('kAlignManip', 912), ('kPluginTransformNode', 913), ('kFluid', 914), ('kFluidGeom', 915), ('kFluidData', 916), ('kSmear', 917), ('kStringShadingSwitch', 918), ('kStudioClearCoat', 919), ('kFluidEmitter', 920), ('kHeightField', 921), ('kGeoConnector', 922), ('kSnapshotPath', 923), ('kPluginObjectSet', 924), ('kQuadShadingSwitch', 925), ('kPolyExtrudeVertex', 926), ('kPairBlend', 927), ('kTextManip', 928), ('kViewManip', 929), ('kXformManip', 930), ('kMute', 931), ('kConstraint', 932), ('kTrimWithBoundaries', 933), ('kCurveFromMeshCoM', 934), ('kFollicle', 935), ('kHairSystem', 936), ('kRemapValue', 937), ('kRemapColor', 938), ('kRemapHsv', 939), ('kHairConstraint', 940), ('kTimeFunction', 941), ('kMentalRayTexture', 942), ('kObjectBinFilter', 943), ('kPolySmoothProxy', 944), ('kPfxGeometry', 945), ('kPfxHair', 946), ('kHairTubeShader', 947), ('kPsdFileTexture', 948), ('kKeyframeDelta', 949), ('kKeyframeDeltaMove', 950), ('kKeyframeDeltaScale', 951), ('kKeyframeDeltaAddRemove', 952), ('kKeyframeDeltaBlockAddRemove', 953), ('kKeyframeDeltaInfType', 954), ('kKeyframeDeltaTangent', 955), ('kKeyframeDeltaWeighted', 956), ('kKeyframeDeltaBreakdown', 957), ('kPolyMirror', 958), ('kPolyCreaseEdge', 959), ('kPolyPinUV', 960), ('kHikEffector', 961), ('kHikIKEffector', 962), ('kHikFKJoint', 963), ('kHikSolver', 964), ('kHikHandle', 965), ('kProxyManager', 966), ('kPolyAutoProjManip', 967), ('kPolyPrism', 968), ('kPolyPyramid', 969), ('kPolySplitRing', 970), ('kPfxToon', 971), ('kToonLineAttributes', 972), ('kPolyDuplicateEdge', 973), ('kFacade', 974), ('kMaterialFacade', 975), ('kEnvFacade', 976), ('kAISEnvFacade', 977), ('kLineModifier', 978), ('kPolyArrow', 979), ('kPolyPrimitiveMisc', 980), ('kPolyPlatonicSolid', 981), ('kPolyPipe', 982), ('kHikFloorContactMarker', 983), ('kHikGroundPlane', 984), ('kPolyComponentData', 985), ('kPolyHelix', 986), ('kCacheFile', 987), ('kHistorySwitch', 988), ('kClosestPointOnMesh', 989), ('kUVPin', 990), ('kProximityPin', 991), ('kTransferAttributes', 992), ('kDynamicConstraint', 993), ('kNComponent', 994), ('kPolyBridgeEdge', 995), ('kCacheableNode', 996), ('kNucleus', 997), ('kNBase', 998), ('kCacheBase', 999), ('kCacheBlend', 1000), ('kCacheTrack', 1001), ('kKeyframeRegionManip', 1002), ('kCurveNormalizerAngle', 1003), ('kCurveNormalizerLinear', 1004), ('kHyperLayoutDG', 1005), ('kPluginImagePlaneNode', 1006), ('kNCloth', 1007), ('kNParticle', 1008), ('kNRigid', 1009), ('kPluginParticleAttributeMapperNode', 1010), ('kCameraSet', 1011), ('kPluginCameraSet', 1012), ('kContainer', 1013), ('kFloatVectorArrayData', 1014), ('kNObjectData', 1015), ('kNObject', 1016), ('kPluginConstraintNode', 1017), ('kAsset', 1018), ('kPolyEdgeToCurve', 1019), ('kAnimLayer', 1020), ('kBlendNodeBase', 1021), ('kBlendNodeBoolean', 1022), ('kBlendNodeDouble', 1023), ('kBlendNodeDoubleAngle', 1024), ('kBlendNodeDoubleLinear', 1025), ('kBlendNodeEnum', 1026), ('kBlendNodeFloat', 1027), ('kBlendNodeFloatAngle', 1028), ('kBlendNodeFloatLinear', 1029), ('kBlendNodeInt16', 1030), ('kBlendNodeInt32', 1031), ('kBlendNodeAdditiveScale', 1032), ('kBlendNodeAdditiveRotation', 1033), ('kPluginManipulatorNode', 1034), ('kNIdData', 1035), ('kNId', 1036), ('kFloatArrayData', 1037), ('kMembrane', 1038), ('kMergeVertsToolManip', 1039), ('kUint64SingleIndexedComponent', 1040), ('kPolyToolFeedbackManip', 1041), ('kPolySelectEditFeedbackManip', 1042), ('kWriteToFrameBuffer', 1043), ('kWriteToColorBuffer', 1044), ('kWriteToVectorBuffer', 1045), ('kWriteToDepthBuffer', 1046), ('kWriteToLabelBuffer', 1047), ('kStereoCameraMaster', 1048), ('kSequenceManager', 1049), ('kSequencer', 1050), ('kShot', 1051), ('kBlendNodeTime', 1052), ('kCreateBezierManip', 1053), ('kBezierCurve', 1054), ('kBezierCurveData', 1055), ('kNurbsCurveToBezier', 1056), ('kBezierCurveToNurbs', 1057), ('kPolySpinEdge', 1058), ('kPolyHoleFace', 1059), ('kPointOnPolyConstraint', 1060), ('kPolyConnectComponents', 1061), ('kSkinBinding', 1062), ('kVolumeBindManip', 1063), ('kVertexWeightSet', 1064), ('kNearestPointOnCurve', 1065), ('kColorProfile', 1066), ('kAdskMaterial', 1067), ('kContainerBase', 1068), ('kDagContainer', 1069), ('kPolyUVRectangle', 1070), ('kHardwareRenderingGlobals', 1071), ('kPolyProjectCurve', 1072), ('kRenderingList', 1073), ('kPolyExtrudeManip', 1074), ('kPolyExtrudeManipContainer', 1075), ('kThreadedDevice', 1076), ('kClientDevice', 1077), ('kPluginClientDevice', 1078), ('kPluginThreadedDevice', 1079), ('kTimeWarp', 1080), ('kAssembly', 1081), ('kClipGhostShape', 1082), ('kClipToGhostData', 1083), ('kMandelbrot', 1084), ('kMandelbrot3D', 1085), ('kGreasePlane', 1086), ('kGreasePlaneRenderShape', 1087), ('kGreasePencilSequence', 1088), ('kEditMetadata', 1089), ('kCreaseSet', 1090), ('kPolyEditEdgeFlow', 1091), ('kFosterParent', 1092), ('kSnapUVManip2D', 1093), ('kToolContext', 1094), ('kNLE', 1095), ('kShrinkWrapFilter', 1096), ('kEditsManager', 1097), ('kPolyBevel2', 1098), ('kPolyCBoolOp', 1099), ('kGeomBind', 1100), ('kColorMgtGlobals', 1101), ('kPolyBevel3', 1102), ('kTimeEditorClipBase', 1103), ('kTimeEditorClipEvaluator', 1104), ('kTimeEditorClip', 1105), ('kTimeEditor', 1106), ('kTimeEditorTracks', 1107), ('kTimeEditorInterpolator', 1108), ('kTimeEditorAnimSource', 1109), ('kCaddyManipBase', 1110), ('kPolyCaddyManip', 1111), ('kPolyModifierManipContainer', 1112), ('kPolyRemesh', 1113), ('kPolyContourProj', 1114), ('kContourProjectionManip', 1115), ('kNodeGraphEditorInfo', 1116), ('kNodeGraphEditorBookmarks', 1117), ('kNodeGraphEditorBookmarkInfo', 1118), ('kPluginSkinCluster', 1119), ('kPluginGeometryFilter', 1120), ('kPluginBlendShape', 1121), ('kPolyPassThru', 1122), ('kTrackInfoManager', 1123), ('kPolyClean', 1124), ('kShapeEditorManager', 1125), ('kOceanDeformer', 1126), ('kPoseInterpolatorManager', 1127), ('kControllerTag', 1128), ('kReForm', 1129), ('kCustomEvaluatorClusterNode', 1130), ('kPolyCircularize', 1131), ('kArubaTesselate', 1132), ('kReorderUVSet', 1133), ('kUfeProxyTransform', 1134), ('kDecomposeMatrix', 1135), ('kComposeMatrix', 1136), ('kBlendMatrix', 1137), ('kPickMatrix', 1138), ('kAimMatrix', 1139), ('kPrimitiveFalloff', 1140), ('kBlendFalloff', 1141), ('kUniformFalloff', 1142), ('kTransferFalloff', 1143), ('kComponentFalloff', 1144), ('kWeightFunctionData', 1145), ('kFalloffEval', 1146), ('kComponentMatch', 1147), ('kLast', 1148)], 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), ('morph', 352), ('kMorph', 352), ('solidify', 353), ('kSolidify', 353), ('proximityWrap', 354), ('kProximityWrap', 354), ('wire', 355), ('kWire', 355), ('groupId', 356), ('kGroupId', 356), ('groupParts', 357), ('kGroupParts', 357), ('guide', 358), ('kGuide', 358), ('hsvToRgb', 359), ('kHsvToRgb', 359), ('hyperGraphInfo', 360), ('kHyperGraphInfo', 360), ('hyperLayout', 361), ('kHyperLayout', 361), ('hyperView', 362), ('kHyperView', 362), ('ikSolver', 363), ('kIkSolver', 363), ('MCsolver', 364), ('kMCsolver', 364), ('PASolver', 365), ('kPASolver', 365), ('SCsolver', 366), ('kSCsolver', 366), ('RPsolver', 367), ('kRPsolver', 367), ('splineSolver', 368), ('kSplineSolver', 368), ('ikSystem', 369), ('kIkSystem', 369), ('imagePlane', 370), ('kImagePlane', 370), ('lambert', 371), ('kLambert', 371), ('reflect', 372), ('kReflect', 372), ('blinn', 373), ('kBlinn', 373), ('phong', 374), ('kPhong', 374), ('phongExplorer', 375), ('kPhongExplorer', 375), ('layeredShader', 376), ('kLayeredShader', 376), ('standardSurface', 377), ('kStandardSurface', 377), ('lightInfo', 378), ('kLightInfo', 378), ('leastSquares', 379), ('kLeastSquares', 379), ('lightFogMaterial', 380), ('kLightFogMaterial', 380), ('envFogMaterial', 381), ('kEnvFogMaterial', 381), ('lightList', 382), ('kLightList', 382), ('lightSource', 383), ('kLightSource', 383), ('luminance', 384), ('kLuminance', 384), ('makeGroup', 385), ('kMakeGroup', 385), ('material', 386), ('kMaterial', 386), ('diffuseMaterial', 387), ('kDiffuseMaterial', 387), ('lambertMaterial', 388), ('kLambertMaterial', 388), ('blinnMaterial', 389), ('kBlinnMaterial', 389), ('phongMaterial', 390), ('kPhongMaterial', 390), ('lightSourceMaterial', 391), ('kLightSourceMaterial', 391), ('materialInfo', 392), ('kMaterialInfo', 392), ('materialTemplate', 393), ('kMaterialTemplate', 393), ('matrixAdd', 394), ('kMatrixAdd', 394), ('matrixHold', 395), ('kMatrixHold', 395), ('matrixMult', 396), ('kMatrixMult', 396), ('matrixPass', 397), ('kMatrixPass', 397), ('matrixWtAdd', 398), ('kMatrixWtAdd', 398), ('midModifier', 399), ('kMidModifier', 399), ('midModifierWithMatrix', 400), ('kMidModifierWithMatrix', 400), ('polyBevel', 401), ('kPolyBevel', 401), ('polyTweak', 402), ('kPolyTweak', 402), ('polyAppend', 403), ('kPolyAppend', 403), ('polyChipOff', 404), ('kPolyChipOff', 404), ('polyCloseBorder', 405), ('kPolyCloseBorder', 405), ('polyCollapseEdge', 406), ('kPolyCollapseEdge', 406), ('polyCollapseF', 407), ('kPolyCollapseF', 407), ('polyCylProj', 408), ('kPolyCylProj', 408), ('polyDelEdge', 409), ('kPolyDelEdge', 409), ('polyDelFacet', 410), ('kPolyDelFacet', 410), ('polyDelVertex', 411), ('kPolyDelVertex', 411), ('polyExtrudeFacet', 412), ('kPolyExtrudeFacet', 412), ('polyMapCut', 413), ('kPolyMapCut', 413), ('polyMapDel', 414), ('kPolyMapDel', 414), ('polyMapSew', 415), ('kPolyMapSew', 415), ('polyMergeEdge', 416), ('kPolyMergeEdge', 416), ('polyMergeFacet', 417), ('kPolyMergeFacet', 417), ('polyMoveEdge', 418), ('kPolyMoveEdge', 418), ('polyMoveFacet', 419), ('kPolyMoveFacet', 419), ('polyMoveFacetUV', 420), ('kPolyMoveFacetUV', 420), ('polyMoveUV', 421), ('kPolyMoveUV', 421), ('polyMoveVertex', 422), ('kPolyMoveVertex', 422), ('polyMoveVertexUV', 423), ('kPolyMoveVertexUV', 423), ('polyNormal', 424), ('kPolyNormal', 424), ('polyPlanProj', 425), ('kPolyPlanProj', 425), ('polyProj', 426), ('kPolyProj', 426), ('polyQuad', 427), ('kPolyQuad', 427), ('polySmooth', 428), ('kPolySmooth', 428), ('polySoftEdge', 429), ('kPolySoftEdge', 429), ('polySphProj', 430), ('kPolySphProj', 430), ('polySplit', 431), ('kPolySplit', 431), ('polySubdEdge', 432), ('kPolySubdEdge', 432), ('polySubdFacet', 433), ('kPolySubdFacet', 433), ('polyTriangulate', 434), ('kPolyTriangulate', 434), ('polyCreator', 435), ('kPolyCreator', 435), ('polyPrimitive', 436), ('kPolyPrimitive', 436), ('polyCone', 437), ('kPolyCone', 437), ('polyCube', 438), ('kPolyCube', 438), ('polyCylinder', 439), ('kPolyCylinder', 439), ('polyMesh', 440), ('kPolyMesh', 440), ('polySphere', 441), ('kPolySphere', 441), ('polyTorus', 442), ('kPolyTorus', 442), ('polyCreateFacet', 443), ('kPolyCreateFacet', 443), ('polyUnite', 444), ('kPolyUnite', 444), ('motionPath', 445), ('kMotionPath', 445), ('pluginMotionPathNode', 446), ('kPluginMotionPathNode', 446), ('multilisterLight', 447), ('kMultilisterLight', 447), ('multiplyDivide', 448), ('kMultiplyDivide', 448), ('oldGeometryConstraint', 449), ('kOldGeometryConstraint', 449), ('opticalFX', 450), ('kOpticalFX', 450), ('particleAgeMapper', 451), ('kParticleAgeMapper', 451), ('particleCloud', 452), ('kParticleCloud', 452), ('particleColorMapper', 453), ('kParticleColorMapper', 453), ('particleIncandecenceMapper', 454), ('kParticleIncandecenceMapper', 454), ('particleTransparencyMapper', 455), ('kParticleTransparencyMapper', 455), ('partition', 456), ('kPartition', 456), ('place2dTexture', 457), ('kPlace2dTexture', 457), ('place3dTexture', 458), ('kPlace3dTexture', 458), ('pluginDependNode', 459), ('kPluginDependNode', 459), ('pluginLocatorNode', 460), ('kPluginLocatorNode', 460), ('plusMinusAverage', 461), ('kPlusMinusAverage', 461), ('pointMatrixMult', 462), ('kPointMatrixMult', 462), ('polySeparate', 463), ('kPolySeparate', 463), ('postProcessList', 464), ('kPostProcessList', 464), ('projection', 465), ('kProjection', 465), ('record', 466), ('kRecord', 466), ('renderUtilityList', 467), ('kRenderUtilityList', 467), ('reverse', 468), ('kReverse', 468), ('rgbToHsv', 469), ('kRgbToHsv', 469), ('rigidSolver', 470), ('kRigidSolver', 470), ('set', 471), ('kSet', 471), ('textureBakeSet', 472), ('kTextureBakeSet', 472), ('vertexBakeSet', 473), ('kVertexBakeSet', 473), ('setRange', 474), ('kSetRange', 474), ('shaderGlow', 475), ('kShaderGlow', 475), ('shaderList', 476), ('kShaderList', 476), ('shadingMap', 477), ('kShadingMap', 477), ('samplerInfo', 478), ('kSamplerInfo', 478), ('shapeFragment', 479), ('kShapeFragment', 479), ('simpleVolumeShader', 480), ('kSimpleVolumeShader', 480), ('sl60', 481), ('kSl60', 481), ('snapshot', 482), ('kSnapshot', 482), ('storyBoard', 483), ('kStoryBoard', 483), ('summaryObject', 484), ('kSummaryObject', 484), ('super', 485), ('kSuper', 485), ('control', 486), ('kControl', 486), ('surfaceLuminance', 487), ('kSurfaceLuminance', 487), ('surfaceShader', 488), ('kSurfaceShader', 488), ('textureList', 489), ('kTextureList', 489), ('textureEnv', 490), ('kTextureEnv', 490), ('envBall', 491), ('kEnvBall', 491), ('envCube', 492), ('kEnvCube', 492), ('envChrome', 493), ('kEnvChrome', 493), ('envSky', 494), ('kEnvSky', 494), ('envSphere', 495), ('kEnvSphere', 495), ('texture2d', 496), ('kTexture2d', 496), ('bulge', 497), ('kBulge', 497), ('checker', 498), ('kChecker', 498), ('cloth', 499), ('kCloth', 499), ('fileTexture', 500), ('kFileTexture', 500), ('fractal', 501), ('kFractal', 501), ('grid', 502), ('kGrid', 502), ('mountain', 503), ('kMountain', 503), ('ramp', 504), ('kRamp', 504), ('stencil', 505), ('kStencil', 505), ('water', 506), ('kWater', 506), ('texture3d', 507), ('kTexture3d', 507), ('brownian', 508), ('kBrownian', 508), ('cloud', 509), ('kCloud', 509), ('crater', 510), ('kCrater', 510), ('granite', 511), ('kGranite', 511), ('leather', 512), ('kLeather', 512), ('marble', 513), ('kMarble', 513), ('rock', 514), ('kRock', 514), ('snow', 515), ('kSnow', 515), ('solidFractal', 516), ('kSolidFractal', 516), ('stucco', 517), ('kStucco', 517), ('txSl', 518), ('kTxSl', 518), ('wood', 519), ('kWood', 519), ('time', 520), ('kTime', 520), ('timeToUnitConversion', 521), ('kTimeToUnitConversion', 521), ('renderSetup', 522), ('kRenderSetup', 522), ('renderGlobals', 523), ('kRenderGlobals', 523), ('renderGlobalsList', 524), ('kRenderGlobalsList', 524), ('renderQuality', 525), ('kRenderQuality', 525), ('resolution', 526), ('kResolution', 526), ('hardwareRenderGlobals', 527), ('kHardwareRenderGlobals', 527), ('arrayMapper', 528), ('kArrayMapper', 528), ('unitConversion', 529), ('kUnitConversion', 529), ('unitToTimeConversion', 530), ('kUnitToTimeConversion', 530), ('useBackground', 531), ('kUseBackground', 531), ('unknown', 532), ('kUnknown', 532), ('vectorProduct', 533), ('kVectorProduct', 533), ('volumeShader', 534), ('kVolumeShader', 534), ('component', 535), ('kComponent', 535), ('curveCVComponent', 536), ('kCurveCVComponent', 536), ('curveEPComponent', 537), ('kCurveEPComponent', 537), ('curveKnotComponent', 538), ('kCurveKnotComponent', 538), ('curveParamComponent', 539), ('kCurveParamComponent', 539), ('isoparmComponent', 540), ('kIsoparmComponent', 540), ('pivotComponent', 541), ('kPivotComponent', 541), ('surfaceCVComponent', 542), ('kSurfaceCVComponent', 542), ('surfaceEPComponent', 543), ('kSurfaceEPComponent', 543), ('surfaceKnotComponent', 544), ('kSurfaceKnotComponent', 544), ('edgeComponent', 545), ('kEdgeComponent', 545), ('latticeComponent', 546), ('kLatticeComponent', 546), ('surfaceRangeComponent', 547), ('kSurfaceRangeComponent', 547), ('decayRegionCapComponent', 548), ('kDecayRegionCapComponent', 548), ('decayRegionComponent', 549), ('kDecayRegionComponent', 549), ('meshComponent', 550), ('kMeshComponent', 550), ('meshEdgeComponent', 551), ('kMeshEdgeComponent', 551), ('meshPolygonComponent', 552), ('kMeshPolygonComponent', 552), ('meshFrEdgeComponent', 553), ('kMeshFrEdgeComponent', 553), ('meshVertComponent', 554), ('kMeshVertComponent', 554), ('meshFaceVertComponent', 555), ('kMeshFaceVertComponent', 555), ('orientationComponent', 556), ('kOrientationComponent', 556), ('subVertexComponent', 557), ('kSubVertexComponent', 557), ('multiSubVertexComponent', 558), ('kMultiSubVertexComponent', 558), ('setGroupComponent', 559), ('kSetGroupComponent', 559), ('dynParticleSetComponent', 560), ('kDynParticleSetComponent', 560), ('selectionItem', 561), ('kSelectionItem', 561), ('dagSelectionItem', 562), ('kDagSelectionItem', 562), ('nonDagSelectionItem', 563), ('kNonDagSelectionItem', 563), ('itemList', 564), ('kItemList', 564), ('attribute', 565), ('kAttribute', 565), ('numericAttribute', 566), ('kNumericAttribute', 566), ('doubleAngleAttribute', 567), ('kDoubleAngleAttribute', 567), ('floatAngleAttribute', 568), ('kFloatAngleAttribute', 568), ('doubleLinearAttribute', 569), ('kDoubleLinearAttribute', 569), ('floatLinearAttribute', 570), ('kFloatLinearAttribute', 570), ('timeAttribute', 571), ('kTimeAttribute', 571), ('enumAttribute', 572), ('kEnumAttribute', 572), ('unitAttribute', 573), ('kUnitAttribute', 573), ('typedAttribute', 574), ('kTypedAttribute', 574), ('compoundAttribute', 575), ('kCompoundAttribute', 575), ('genericAttribute', 576), ('kGenericAttribute', 576), ('lightDataAttribute', 577), ('kLightDataAttribute', 577), ('matrixAttribute', 578), ('kMatrixAttribute', 578), ('floatMatrixAttribute', 579), ('kFloatMatrixAttribute', 579), ('messageAttribute', 580), ('kMessageAttribute', 580), ('plugin', 581), ('kPlugin', 581), ('data', 582), ('kData', 582), ('componentListData', 583), ('kComponentListData', 583), ('doubleArrayData', 584), ('kDoubleArrayData', 584), ('intArrayData', 585), ('kIntArrayData', 585), ('uintArrayData', 586), ('kUintArrayData', 586), ('latticeData', 587), ('kLatticeData', 587), ('matrixData', 588), ('kMatrixData', 588), ('meshData', 589), ('kMeshData', 589), ('nurbsSurfaceData', 590), ('kNurbsSurfaceData', 590), ('nurbsCurveData', 591), ('kNurbsCurveData', 591), ('numericData', 592), ('kNumericData', 592), ('data2Double', 593), ('kData2Double', 593), ('data2Float', 594), ('kData2Float', 594), ('data2Int', 595), ('data2Long', 595), ('kData2Int', 595), ('kData2Long', 595), ('data2Short', 596), ('kData2Short', 596), ('data3Double', 597), ('kData3Double', 597), ('data3Float', 598), ('kData3Float', 598), ('data3Int', 599), ('data3Long', 599), ('kData3Int', 599), ('kData3Long', 599), ('data3Short', 600), ('kData3Short', 600), ('pluginData', 601), ('kPluginData', 601), ('pointArrayData', 602), ('kPointArrayData', 602), ('matrixArrayData', 603), ('kMatrixArrayData', 603), ('sphereData', 604), ('kSphereData', 604), ('stringData', 605), ('kStringData', 605), ('stringArrayData', 606), ('kStringArrayData', 606), ('vectorArrayData', 607), ('kVectorArrayData', 607), ('selectionList', 608), ('kSelectionList', 608), ('transformGeometry', 609), ('kTransformGeometry', 609), ('commEdgePtManip', 610), ('kCommEdgePtManip', 610), ('commEdgeOperManip', 611), ('kCommEdgeOperManip', 611), ('commEdgeSegmentManip', 612), ('kCommEdgeSegmentManip', 612), ('commCornerManip', 613), ('kCommCornerManip', 613), ('commCornerOperManip', 614), ('kCommCornerOperManip', 614), ('pluginDeformerNode', 615), ('kPluginDeformerNode', 615), ('torus', 616), ('kTorus', 616), ('polyBoolOp', 617), ('kPolyBoolOp', 617), ('singleShadingSwitch', 618), ('kSingleShadingSwitch', 618), ('doubleShadingSwitch', 619), ('kDoubleShadingSwitch', 619), ('tripleShadingSwitch', 620), ('kTripleShadingSwitch', 620), ('nurbsSquare', 621), ('kNurbsSquare', 621), ('anisotropy', 622), ('kAnisotropy', 622), ('nonLinear', 623), ('kNonLinear', 623), ('deformFunc', 624), ('kDeformFunc', 624), ('deformBend', 625), ('kDeformBend', 625), ('deformTwist', 626), ('kDeformTwist', 626), ('deformSquash', 627), ('kDeformSquash', 627), ('deformFlare', 628), ('kDeformFlare', 628), ('deformSine', 629), ('kDeformSine', 629), ('deformWave', 630), ('kDeformWave', 630), ('deformBendManip', 631), ('kDeformBendManip', 631), ('deformTwistManip', 632), ('kDeformTwistManip', 632), ('deformSquashManip', 633), ('kDeformSquashManip', 633), ('deformFlareManip', 634), ('kDeformFlareManip', 634), ('deformSineManip', 635), ('kDeformSineManip', 635), ('deformWaveManip', 636), ('kDeformWaveManip', 636), ('softModManip', 637), ('kSoftModManip', 637), ('distanceManip', 638), ('kDistanceManip', 638), ('script', 639), ('kScript', 639), ('curveFromMeshEdge', 640), ('kCurveFromMeshEdge', 640), ('curveCurveIntersect', 641), ('kCurveCurveIntersect', 641), ('nurbsCircular3PtArc', 642), ('kNurbsCircular3PtArc', 642), ('nurbsCircular2PtArc', 643), ('kNurbsCircular2PtArc', 643), ('offsetSurface', 644), ('kOffsetSurface', 644), ('roundConstantRadius', 645), ('kRoundConstantRadius', 645), ('roundRadiusManip', 646), ('kRoundRadiusManip', 646), ('roundRadiusCrvManip', 647), ('kRoundRadiusCrvManip', 647), ('roundConstantRadiusManip', 648), ('kRoundConstantRadiusManip', 648), ('threePointArcManip', 649), ('kThreePointArcManip', 649), ('twoPointArcManip', 650), ('kTwoPointArcManip', 650), ('textButtonManip', 651), ('kTextButtonManip', 651), ('offsetSurfaceManip', 652), ('kOffsetSurfaceManip', 652), ('imageData', 653), ('kImageData', 653), ('imageLoad', 654), ('kImageLoad', 654), ('imageSave', 655), ('kImageSave', 655), ('imageNetSrc', 656), ('kImageNetSrc', 656), ('imageNetDest', 657), ('kImageNetDest', 657), ('imageRender', 658), ('kImageRender', 658), ('imageAdd', 659), ('kImageAdd', 659), ('imageDiff', 660), ('kImageDiff', 660), ('imageMultiply', 661), ('kImageMultiply', 661), ('imageOver', 662), ('kImageOver', 662), ('imageUnder', 663), ('kImageUnder', 663), ('imageColorCorrect', 664), ('kImageColorCorrect', 664), ('imageBlur', 665), ('kImageBlur', 665), ('imageFilter', 666), ('kImageFilter', 666), ('imageDepth', 667), ('kImageDepth', 667), ('imageDisplay', 668), ('kImageDisplay', 668), ('imageView', 669), ('kImageView', 669), ('imageMotionBlur', 670), ('kImageMotionBlur', 670), ('viewColorManager', 671), ('kViewColorManager', 671), ('matrixFloatData', 672), ('kMatrixFloatData', 672), ('skinShader', 673), ('kSkinShader', 673), ('componentManip', 674), ('kComponentManip', 674), ('selectionListData', 675), ('kSelectionListData', 675), ('objectFilter', 676), ('kObjectFilter', 676), ('objectMultiFilter', 677), ('kObjectMultiFilter', 677), ('objectNameFilter', 678), ('kObjectNameFilter', 678), ('objectTypeFilter', 679), ('kObjectTypeFilter', 679), ('objectAttrFilter', 680), ('kObjectAttrFilter', 680), ('objectRenderFilter', 681), ('kObjectRenderFilter', 681), ('objectScriptFilter', 682), ('kObjectScriptFilter', 682), ('selectionListOperator', 683), ('kSelectionListOperator', 683), ('subdiv', 684), ('kSubdiv', 684), ('polyToSubdiv', 685), ('kPolyToSubdiv', 685), ('skinClusterFilter', 686), ('kSkinClusterFilter', 686), ('keyingGroup', 687), ('kKeyingGroup', 687), ('character', 688), ('kCharacter', 688), ('characterOffset', 689), ('kCharacterOffset', 689), ('dagPose', 690), ('kDagPose', 690), ('stitchAsNurbsShell', 691), ('kStitchAsNurbsShell', 691), ('explodeNurbsShell', 692), ('kExplodeNurbsShell', 692), ('nurbsBoolean', 693), ('kNurbsBoolean', 693), ('stitchSrfManip', 694), ('kStitchSrfManip', 694), ('forceUpdateManip', 695), ('kForceUpdateManip', 695), ('pluginManipContainer', 696), ('kPluginManipContainer', 696), ('polySewEdge', 697), ('kPolySewEdge', 697), ('polyMergeVert', 698), ('kPolyMergeVert', 698), ('polySmoothFacet', 699), ('kPolySmoothFacet', 699), ('smoothCurve', 700), ('kSmoothCurve', 700), ('globalStitch', 701), ('kGlobalStitch', 701), ('subdivCVComponent', 702), ('kSubdivCVComponent', 702), ('subdivEdgeComponent', 703), ('kSubdivEdgeComponent', 703), ('subdivFaceComponent', 704), ('kSubdivFaceComponent', 704), ('UVManip2D', 705), ('kUVManip2D', 705), ('translateUVManip2D', 706), ('kTranslateUVManip2D', 706), ('rotateUVManip2D', 707), ('kRotateUVManip2D', 707), ('scaleUVManip2D', 708), ('kScaleUVManip2D', 708), ('polyTweakUV', 709), ('kPolyTweakUV', 709), ('moveUVShellManip2D', 710), ('kMoveUVShellManip2D', 710), ('pluginShape', 711), ('kPluginShape', 711), ('geometryData', 712), ('kGeometryData', 712), ('singleIndexedComponent', 713), ('kSingleIndexedComponent', 713), ('doubleIndexedComponent', 714), ('kDoubleIndexedComponent', 714), ('tripleIndexedComponent', 715), ('kTripleIndexedComponent', 715), ('extendSurfaceDistanceManip', 716), ('kExtendSurfaceDistanceManip', 716), ('squareSrf', 717), ('kSquareSrf', 717), ('squareSrfManip', 718), ('kSquareSrfManip', 718), ('subdivToPoly', 719), ('kSubdivToPoly', 719), ('dynBase', 720), ('kDynBase', 720), ('dynEmitterManip', 721), ('kDynEmitterManip', 721), ('dynFieldsManip', 722), ('kDynFieldsManip', 722), ('dynBaseFieldManip', 723), ('kDynBaseFieldManip', 723), ('dynAirManip', 724), ('kDynAirManip', 724), ('dynNewtonManip', 725), ('kDynNewtonManip', 725), ('dynTurbulenceManip', 726), ('kDynTurbulenceManip', 726), ('dynSpreadManip', 727), ('kDynSpreadManip', 727), ('dynAttenuationManip', 728), ('kDynAttenuationManip', 728), ('dynArrayAttrsData', 729), ('kDynArrayAttrsData', 729), ('pluginFieldNode', 730), ('kPluginFieldNode', 730), ('pluginEmitterNode', 731), ('kPluginEmitterNode', 731), ('pluginSpringNode', 732), ('kPluginSpringNode', 732), ('displayLayer', 733), ('kDisplayLayer', 733), ('displayLayerManager', 734), ('kDisplayLayerManager', 734), ('polyColorPerVertex', 735), ('kPolyColorPerVertex', 735), ('createColorSet', 736), ('kCreateColorSet', 736), ('deleteColorSet', 737), ('kDeleteColorSet', 737), ('copyColorSet', 738), ('kCopyColorSet', 738), ('blendColorSet', 739), ('kBlendColorSet', 739), ('polyColorMod', 740), ('kPolyColorMod', 740), ('polyColorDel', 741), ('kPolyColorDel', 741), ('characterMappingData', 742), ('kCharacterMappingData', 742), ('dynSweptGeometryData', 743), ('kDynSweptGeometryData', 743), ('wrapFilter', 744), ('kWrapFilter', 744), ('meshVtxFaceComponent', 745), ('kMeshVtxFaceComponent', 745), ('binaryData', 746), ('kBinaryData', 746), ('attribute2Double', 747), ('kAttribute2Double', 747), ('attribute2Float', 748), ('kAttribute2Float', 748), ('attribute2Short', 749), ('kAttribute2Short', 749), ('attribute2Int', 750), ('attribute2Long', 750), ('kAttribute2Int', 750), ('kAttribute2Long', 750), ('attribute3Double', 751), ('kAttribute3Double', 751), ('attribute3Float', 752), ('kAttribute3Float', 752), ('attribute3Short', 753), ('kAttribute3Short', 753), ('attribute3Int', 754), ('attribute3Long', 754), ('kAttribute3Int', 754), ('kAttribute3Long', 754), ('reference', 755), ('kReference', 755), ('blindData', 756), ('kBlindData', 756), ('blindDataTemplate', 757), ('kBlindDataTemplate', 757), ('polyBlindData', 758), ('kPolyBlindData', 758), ('polyNormalPerVertex', 759), ('kPolyNormalPerVertex', 759), ('nurbsToSubdiv', 760), ('kNurbsToSubdiv', 760), ('pluginIkSolver', 761), ('kPluginIkSolver', 761), ('instancer', 762), ('kInstancer', 762), ('moveVertexManip', 763), ('kMoveVertexManip', 763), ('stroke', 764), ('kStroke', 764), ('brush', 765), ('kBrush', 765), ('strokeGlobals', 766), ('kStrokeGlobals', 766), ('pluginGeometryData', 767), ('kPluginGeometryData', 767), ('lightLink', 768), ('kLightLink', 768), ('dynGlobals', 769), ('kDynGlobals', 769), ('polyReduce', 770), ('kPolyReduce', 770), ('lodThresholds', 771), ('kLodThresholds', 771), ('chooser', 772), ('kChooser', 772), ('lodGroup', 773), ('kLodGroup', 773), ('multDoubleLinear', 774), ('kMultDoubleLinear', 774), ('fourByFourMatrix', 775), ('kFourByFourMatrix', 775), ('towPointOnSurfaceManip', 776), ('kTowPointOnSurfaceManip', 776), ('surfaceEdManip', 777), ('kSurfaceEdManip', 777), ('surfaceFaceComponent', 778), ('kSurfaceFaceComponent', 778), ('clipScheduler', 779), ('kClipScheduler', 779), ('clipLibrary', 780), ('kClipLibrary', 780), ('subSurface', 781), ('kSubSurface', 781), ('smoothTangentSrf', 782), ('kSmoothTangentSrf', 782), ('renderPass', 783), ('kRenderPass', 783), ('renderPassSet', 784), ('kRenderPassSet', 784), ('renderLayer', 785), ('kRenderLayer', 785), ('renderLayerManager', 786), ('kRenderLayerManager', 786), ('passContributionMap', 787), ('kPassContributionMap', 787), ('precompExport', 788), ('kPrecompExport', 788), ('renderTarget', 789), ('kRenderTarget', 789), ('renderedImageSource', 790), ('kRenderedImageSource', 790), ('imageSource', 791), ('kImageSource', 791), ('polyFlipEdge', 792), ('kPolyFlipEdge', 792), ('polyExtrudeEdge', 793), ('kPolyExtrudeEdge', 793), ('animBlend', 794), ('kAnimBlend', 794), ('animBlendInOut', 795), ('kAnimBlendInOut', 795), ('polyAppendVertex', 796), ('kPolyAppendVertex', 796), ('uvChooser', 797), ('kUvChooser', 797), ('subdivCompId', 798), ('kSubdivCompId', 798), ('volumeAxis', 799), ('kVolumeAxis', 799), ('deleteUVSet', 800), ('kDeleteUVSet', 800), ('subdHierBlind', 801), ('kSubdHierBlind', 801), ('subdBlindData', 802), ('kSubdBlindData', 802), ('characterMap', 803), ('kCharacterMap', 803), ('layeredTexture', 804), ('kLayeredTexture', 804), ('subdivCollapse', 805), ('kSubdivCollapse', 805), ('particleSamplerInfo', 806), ('kParticleSamplerInfo', 806), ('copyUVSet', 807), ('kCopyUVSet', 807), ('createUVSet', 808), ('kCreateUVSet', 808), ('clip', 809), ('kClip', 809), ('polySplitVert', 810), ('kPolySplitVert', 810), ('subdivData', 811), ('kSubdivData', 811), ('subdivGeom', 812), ('kSubdivGeom', 812), ('UInt64ArrayData', 813), ('kUInt64ArrayData', 813), ('int64ArrayData', 814), ('kInt64ArrayData', 814), ('polySplitEdge', 815), ('kPolySplitEdge', 815), ('subdivReverseFaces', 816), ('kSubdivReverseFaces', 816), ('meshMapComponent', 817), ('kMeshMapComponent', 817), ('sectionManip', 818), ('kSectionManip', 818), ('xsectionSubdivEdit', 819), ('kXsectionSubdivEdit', 819), ('subdivToNurbs', 820), ('kSubdivToNurbs', 820), ('editCurve', 821), ('kEditCurve', 821), ('editCurveManip', 822), ('kEditCurveManip', 822), ('crossSectionManager', 823), ('kCrossSectionManager', 823), ('createSectionManip', 824), ('kCreateSectionManip', 824), ('crossSectionEditManip', 825), ('kCrossSectionEditManip', 825), ('dropOffFunction', 826), ('kDropOffFunction', 826), ('subdBoolean', 827), ('kSubdBoolean', 827), ('subdModifyEdge', 828), ('kSubdModifyEdge', 828), ('modifyEdgeCrvManip', 829), ('kModifyEdgeCrvManip', 829), ('modifyEdgeManip', 830), ('kModifyEdgeManip', 830), ('scalePointManip', 831), ('kScalePointManip', 831), ('transformBoxManip', 832), ('kTransformBoxManip', 832), ('symmetryLocator', 833), ('kSymmetryLocator', 833), ('symmetryMapVector', 834), ('kSymmetryMapVector', 834), ('symmetryMapCurve', 835), ('kSymmetryMapCurve', 835), ('curveFromSubdivEdge', 836), ('kCurveFromSubdivEdge', 836), ('createBPManip', 837), ('kCreateBPManip', 837), ('modifyEdgeBaseManip', 838), ('kModifyEdgeBaseManip', 838), ('subdExtrudeFace', 839), ('kSubdExtrudeFace', 839), ('subdivSurfaceVarGroup', 840), ('kSubdivSurfaceVarGroup', 840), ('sfRevolveManip', 841), ('kSfRevolveManip', 841), ('curveFromSubdivFace', 842), ('kCurveFromSubdivFace', 842), ('unused1', 843), ('kUnused1', 843), ('unused2', 844), ('kUnused2', 844), ('unused3', 845), ('kUnused3', 845), ('unused4', 846), ('kUnused4', 846), ('unused5', 847), ('kUnused5', 847), ('unused6', 848), ('kUnused6', 848), ('polyTransfer', 849), ('kPolyTransfer', 849), ('polyAverageVertex', 850), ('kPolyAverageVertex', 850), ('polyAutoProj', 851), ('kPolyAutoProj', 851), ('polyLayoutUV', 852), ('kPolyLayoutUV', 852), ('polyMapSewMove', 853), ('kPolyMapSewMove', 853), ('subdModifier', 854), ('kSubdModifier', 854), ('subdMoveVertex', 855), ('kSubdMoveVertex', 855), ('subdMoveEdge', 856), ('kSubdMoveEdge', 856), ('subdMoveFace', 857), ('kSubdMoveFace', 857), ('subdDelFace', 858), ('kSubdDelFace', 858), ('snapshotShape', 859), ('kSnapshotShape', 859), ('subdivMapComponent', 860), ('kSubdivMapComponent', 860), ('jiggleDeformer', 861), ('kJiggleDeformer', 861), ('globalCacheControls', 862), ('kGlobalCacheControls', 862), ('diskCache', 863), ('kDiskCache', 863), ('subdCloseBorder', 864), ('kSubdCloseBorder', 864), ('subdMergeVert', 865), ('kSubdMergeVert', 865), ('boxData', 866), ('kBoxData', 866), ('box', 867), ('kBox', 867), ('renderBox', 868), ('kRenderBox', 868), ('subdSplitFace', 869), ('kSubdSplitFace', 869), ('volumeFog', 870), ('kVolumeFog', 870), ('subdTweakUV', 871), ('kSubdTweakUV', 871), ('subdMapCut', 872), ('kSubdMapCut', 872), ('subdLayoutUV', 873), ('kSubdLayoutUV', 873), ('subdMapSewMove', 874), ('kSubdMapSewMove', 874), ('ocean', 875), ('kOcean', 875), ('volumeNoise', 876), ('kVolumeNoise', 876), ('subdAutoProj', 877), ('kSubdAutoProj', 877), ('subdSubdivideFace', 878), ('kSubdSubdivideFace', 878), ('noise', 879), ('kNoise', 879), ('attribute4Double', 880), ('kAttribute4Double', 880), ('data4Double', 881), ('kData4Double', 881), ('subdPlanProj', 882), ('kSubdPlanProj', 882), ('subdTweak', 883), ('kSubdTweak', 883), ('subdProjectionManip', 884), ('kSubdProjectionManip', 884), ('subdMappingManip', 885), ('kSubdMappingManip', 885), ('hardwareReflectionMap', 886), ('kHardwareReflectionMap', 886), ('polyNormalizeUV', 887), ('kPolyNormalizeUV', 887), ('polyFlipUV', 888), ('kPolyFlipUV', 888), ('hwShaderNode', 889), ('kHwShaderNode', 889), ('pluginHardwareShader', 890), ('kPluginHardwareShader', 890), ('pluginHwShaderNode', 891), ('kPluginHwShaderNode', 891), ('subdAddTopology', 892), ('kSubdAddTopology', 892), ('subdCleanTopology', 893), ('kSubdCleanTopology', 893), ('implicitCone', 894), ('kImplicitCone', 894), ('implicitSphere', 895), ('kImplicitSphere', 895), ('rampShader', 896), ('kRampShader', 896), ('volumeLight', 897), ('kVolumeLight', 897), ('oceanShader', 898), ('kOceanShader', 898), ('bevelPlus', 899), ('kBevelPlus', 899), ('styleCurve', 900), ('kStyleCurve', 900), ('polyCut', 901), ('kPolyCut', 901), ('polyPoke', 902), ('kPolyPoke', 902), ('polyWedgeFace', 903), ('kPolyWedgeFace', 903), ('polyCutManipContainer', 904), ('kPolyCutManipContainer', 904), ('polyCutManip', 905), ('kPolyCutManip', 905), ('polyMirrorManipContainer', 906), ('kPolyMirrorManipContainer', 906), ('polyPokeManip', 907), ('kPolyPokeManip', 907), ('fluidTexture3D', 908), ('kFluidTexture3D', 908), ('fluidTexture2D', 909), ('kFluidTexture2D', 909), ('polyMergeUV', 910), ('kPolyMergeUV', 910), ('polyStraightenUVBorder', 911), ('kPolyStraightenUVBorder', 911), ('alignManip', 912), ('kAlignManip', 912), ('pluginTransformNode', 913), ('kPluginTransformNode', 913), ('fluid', 914), ('kFluid', 914), ('fluidGeom', 915), ('kFluidGeom', 915), ('fluidData', 916), ('kFluidData', 916), ('smear', 917), ('kSmear', 917), ('stringShadingSwitch', 918), ('kStringShadingSwitch', 918), ('studioClearCoat', 919), ('kStudioClearCoat', 919), ('fluidEmitter', 920), ('kFluidEmitter', 920), ('heightField', 921), ('kHeightField', 921), ('geoConnector', 922), ('kGeoConnector', 922), ('snapshotPath', 923), ('kSnapshotPath', 923), ('pluginObjectSet', 924), ('kPluginObjectSet', 924), ('quadShadingSwitch', 925), ('kQuadShadingSwitch', 925), ('polyExtrudeVertex', 926), ('kPolyExtrudeVertex', 926), ('pairBlend', 927), ('kPairBlend', 927), ('textManip', 928), ('kTextManip', 928), ('viewManip', 929), ('kViewManip', 929), ('xformManip', 930), ('kXformManip', 930), ('mute', 931), ('kMute', 931), ('constraint', 932), ('kConstraint', 932), ('trimWithBoundaries', 933), ('kTrimWithBoundaries', 933), ('curveFromMeshCoM', 934), ('kCurveFromMeshCoM', 934), ('follicle', 935), ('kFollicle', 935), ('hairSystem', 936), ('kHairSystem', 936), ('remapValue', 937), ('kRemapValue', 937), ('remapColor', 938), ('kRemapColor', 938), ('remapHsv', 939), ('kRemapHsv', 939), ('hairConstraint', 940), ('kHairConstraint', 940), ('timeFunction', 941), ('kTimeFunction', 941), ('mentalRayTexture', 942), ('kMentalRayTexture', 942), ('objectBinFilter', 943), ('kObjectBinFilter', 943), ('polySmoothProxy', 944), ('kPolySmoothProxy', 944), ('pfxGeometry', 945), ('kPfxGeometry', 945), ('pfxHair', 946), ('kPfxHair', 946), ('hairTubeShader', 947), ('kHairTubeShader', 947), ('psdFileTexture', 948), ('kPsdFileTexture', 948), ('keyframeDelta', 949), ('kKeyframeDelta', 949), ('keyframeDeltaMove', 950), ('kKeyframeDeltaMove', 950), ('keyframeDeltaScale', 951), ('kKeyframeDeltaScale', 951), ('keyframeDeltaAddRemove', 952), ('kKeyframeDeltaAddRemove', 952), ('keyframeDeltaBlockAddRemove', 953), ('kKeyframeDeltaBlockAddRemove', 953), ('keyframeDeltaInfType', 954), ('kKeyframeDeltaInfType', 954), ('keyframeDeltaTangent', 955), ('kKeyframeDeltaTangent', 955), ('keyframeDeltaWeighted', 956), ('kKeyframeDeltaWeighted', 956), ('keyframeDeltaBreakdown', 957), ('kKeyframeDeltaBreakdown', 957), ('polyMirror', 958), ('kPolyMirror', 958), ('polyCreaseEdge', 959), ('kPolyCreaseEdge', 959), ('polyPinUV', 960), ('kPolyPinUV', 960), ('hikEffector', 961), ('kHikEffector', 961), ('hikIKEffector', 962), ('kHikIKEffector', 962), ('hikFKJoint', 963), ('kHikFKJoint', 963), ('hikSolver', 964), ('kHikSolver', 964), ('hikHandle', 965), ('kHikHandle', 965), ('proxyManager', 966), ('kProxyManager', 966), ('polyAutoProjManip', 967), ('kPolyAutoProjManip', 967), ('polyPrism', 968), ('kPolyPrism', 968), ('polyPyramid', 969), ('kPolyPyramid', 969), ('polySplitRing', 970), ('kPolySplitRing', 970), ('pfxToon', 971), ('kPfxToon', 971), ('toonLineAttributes', 972), ('kToonLineAttributes', 972), ('polyDuplicateEdge', 973), ('kPolyDuplicateEdge', 973), ('facade', 974), ('kFacade', 974), ('materialFacade', 975), ('kMaterialFacade', 975), ('envFacade', 976), ('kEnvFacade', 976), ('AISEnvFacade', 977), ('kAISEnvFacade', 977), ('lineModifier', 978), ('kLineModifier', 978), ('polyArrow', 979), ('kPolyArrow', 979), ('polyPrimitiveMisc', 980), ('kPolyPrimitiveMisc', 980), ('polyPlatonicSolid', 981), ('kPolyPlatonicSolid', 981), ('polyPipe', 982), ('kPolyPipe', 982), ('hikFloorContactMarker', 983), ('kHikFloorContactMarker', 983), ('hikGroundPlane', 984), ('kHikGroundPlane', 984), ('polyComponentData', 985), ('kPolyComponentData', 985), ('polyHelix', 986), ('kPolyHelix', 986), ('cacheFile', 987), ('kCacheFile', 987), ('historySwitch', 988), ('kHistorySwitch', 988), ('closestPointOnMesh', 989), ('kClosestPointOnMesh', 989), ('UVPin', 990), ('kUVPin', 990), ('proximityPin', 991), ('kProximityPin', 991), ('transferAttributes', 992), ('kTransferAttributes', 992), ('dynamicConstraint', 993), ('kDynamicConstraint', 993), ('NComponent', 994), ('kNComponent', 994), ('polyBridgeEdge', 995), ('kPolyBridgeEdge', 995), ('cacheableNode', 996), ('kCacheableNode', 996), ('nucleus', 997), ('kNucleus', 997), ('NBase', 998), ('kNBase', 998), ('cacheBase', 999), ('kCacheBase', 999), ('cacheBlend', 1000), ('kCacheBlend', 1000), ('cacheTrack', 1001), ('kCacheTrack', 1001), ('keyframeRegionManip', 1002), ('kKeyframeRegionManip', 1002), ('curveNormalizerAngle', 1003), ('kCurveNormalizerAngle', 1003), ('curveNormalizerLinear', 1004), ('kCurveNormalizerLinear', 1004), ('hyperLayoutDG', 1005), ('kHyperLayoutDG', 1005), ('pluginImagePlaneNode', 1006), ('kPluginImagePlaneNode', 1006), ('NCloth', 1007), ('kNCloth', 1007), ('NParticle', 1008), ('kNParticle', 1008), ('NRigid', 1009), ('kNRigid', 1009), ('pluginParticleAttributeMapperNode', 1010), ('kPluginParticleAttributeMapperNode', 1010), ('cameraSet', 1011), ('kCameraSet', 1011), ('pluginCameraSet', 1012), ('kPluginCameraSet', 1012), ('container', 1013), ('kContainer', 1013), ('floatVectorArrayData', 1014), ('kFloatVectorArrayData', 1014), ('NObjectData', 1015), ('kNObjectData', 1015), ('NObject', 1016), ('kNObject', 1016), ('pluginConstraintNode', 1017), ('kPluginConstraintNode', 1017), ('asset', 1018), ('kAsset', 1018), ('polyEdgeToCurve', 1019), ('kPolyEdgeToCurve', 1019), ('animLayer', 1020), ('kAnimLayer', 1020), ('blendNodeBase', 1021), ('kBlendNodeBase', 1021), ('blendNodeBoolean', 1022), ('kBlendNodeBoolean', 1022), ('blendNodeDouble', 1023), ('kBlendNodeDouble', 1023), ('blendNodeDoubleAngle', 1024), ('kBlendNodeDoubleAngle', 1024), ('blendNodeDoubleLinear', 1025), ('kBlendNodeDoubleLinear', 1025), ('blendNodeEnum', 1026), ('kBlendNodeEnum', 1026), ('blendNodeFloat', 1027), ('kBlendNodeFloat', 1027), ('blendNodeFloatAngle', 1028), ('kBlendNodeFloatAngle', 1028), ('blendNodeFloatLinear', 1029), ('kBlendNodeFloatLinear', 1029), ('blendNodeInt16', 1030), ('kBlendNodeInt16', 1030), ('blendNodeInt32', 1031), ('kBlendNodeInt32', 1031), ('blendNodeAdditiveScale', 1032), ('kBlendNodeAdditiveScale', 1032), ('blendNodeAdditiveRotation', 1033), ('kBlendNodeAdditiveRotation', 1033), ('pluginManipulatorNode', 1034), ('kPluginManipulatorNode', 1034), ('NIdData', 1035), ('kNIdData', 1035), ('NId', 1036), ('kNId', 1036), ('floatArrayData', 1037), ('kFloatArrayData', 1037), ('membrane', 1038), ('kMembrane', 1038), ('mergeVertsToolManip', 1039), ('kMergeVertsToolManip', 1039), ('uint64SingleIndexedComponent', 1040), ('kUint64SingleIndexedComponent', 1040), ('polyToolFeedbackManip', 1041), ('kPolyToolFeedbackManip', 1041), ('polySelectEditFeedbackManip', 1042), ('kPolySelectEditFeedbackManip', 1042), ('writeToFrameBuffer', 1043), ('kWriteToFrameBuffer', 1043), ('writeToColorBuffer', 1044), ('kWriteToColorBuffer', 1044), ('writeToVectorBuffer', 1045), ('kWriteToVectorBuffer', 1045), ('writeToDepthBuffer', 1046), ('kWriteToDepthBuffer', 1046), ('writeToLabelBuffer', 1047), ('kWriteToLabelBuffer', 1047), ('stereoCameraMaster', 1048), ('kStereoCameraMaster', 1048), ('sequenceManager', 1049), ('kSequenceManager', 1049), ('sequencer', 1050), ('kSequencer', 1050), ('shot', 1051), ('kShot', 1051), ('blendNodeTime', 1052), ('kBlendNodeTime', 1052), ('createBezierManip', 1053), ('kCreateBezierManip', 1053), ('bezierCurve', 1054), ('kBezierCurve', 1054), ('bezierCurveData', 1055), ('kBezierCurveData', 1055), ('nurbsCurveToBezier', 1056), ('kNurbsCurveToBezier', 1056), ('bezierCurveToNurbs', 1057), ('kBezierCurveToNurbs', 1057), ('polySpinEdge', 1058), ('kPolySpinEdge', 1058), ('polyHoleFace', 1059), ('kPolyHoleFace', 1059), ('pointOnPolyConstraint', 1060), ('kPointOnPolyConstraint', 1060), ('polyConnectComponents', 1061), ('kPolyConnectComponents', 1061), ('skinBinding', 1062), ('kSkinBinding', 1062), ('volumeBindManip', 1063), ('kVolumeBindManip', 1063), ('vertexWeightSet', 1064), ('kVertexWeightSet', 1064), ('nearestPointOnCurve', 1065), ('kNearestPointOnCurve', 1065), ('colorProfile', 1066), ('kColorProfile', 1066), ('adskMaterial', 1067), ('kAdskMaterial', 1067), ('containerBase', 1068), ('kContainerBase', 1068), ('dagContainer', 1069), ('kDagContainer', 1069), ('polyUVRectangle', 1070), ('kPolyUVRectangle', 1070), ('hardwareRenderingGlobals', 1071), ('kHardwareRenderingGlobals', 1071), ('polyProjectCurve', 1072), ('kPolyProjectCurve', 1072), ('renderingList', 1073), ('kRenderingList', 1073), ('polyExtrudeManip', 1074), ('kPolyExtrudeManip', 1074), ('polyExtrudeManipContainer', 1075), ('kPolyExtrudeManipContainer', 1075), ('threadedDevice', 1076), ('kThreadedDevice', 1076), ('clientDevice', 1077), ('kClientDevice', 1077), ('pluginClientDevice', 1078), ('kPluginClientDevice', 1078), ('pluginThreadedDevice', 1079), ('kPluginThreadedDevice', 1079), ('timeWarp', 1080), ('kTimeWarp', 1080), ('assembly', 1081), ('kAssembly', 1081), ('clipGhostShape', 1082), ('kClipGhostShape', 1082), ('clipToGhostData', 1083), ('kClipToGhostData', 1083), ('mandelbrot', 1084), ('kMandelbrot', 1084), ('mandelbrot3D', 1085), ('kMandelbrot3D', 1085), ('greasePlane', 1086), ('kGreasePlane', 1086), ('greasePlaneRenderShape', 1087), ('kGreasePlaneRenderShape', 1087), ('greasePencilSequence', 1088), ('kGreasePencilSequence', 1088), ('editMetadata', 1089), ('kEditMetadata', 1089), ('creaseSet', 1090), ('kCreaseSet', 1090), ('polyEditEdgeFlow', 1091), ('kPolyEditEdgeFlow', 1091), ('fosterParent', 1092), ('kFosterParent', 1092), ('snapUVManip2D', 1093), ('kSnapUVManip2D', 1093), ('toolContext', 1094), ('kToolContext', 1094), ('NLE', 1095), ('kNLE', 1095), ('shrinkWrapFilter', 1096), ('kShrinkWrapFilter', 1096), ('editsManager', 1097), ('kEditsManager', 1097), ('polyBevel2', 1098), ('kPolyBevel2', 1098), ('polyCBoolOp', 1099), ('kPolyCBoolOp', 1099), ('geomBind', 1100), ('kGeomBind', 1100), ('colorMgtGlobals', 1101), ('kColorMgtGlobals', 1101), ('polyBevel3', 1102), ('kPolyBevel3', 1102), ('timeEditorClipBase', 1103), ('kTimeEditorClipBase', 1103), ('timeEditorClipEvaluator', 1104), ('kTimeEditorClipEvaluator', 1104), ('timeEditorClip', 1105), ('kTimeEditorClip', 1105), ('timeEditor', 1106), ('kTimeEditor', 1106), ('timeEditorTracks', 1107), ('kTimeEditorTracks', 1107), ('timeEditorInterpolator', 1108), ('kTimeEditorInterpolator', 1108), ('timeEditorAnimSource', 1109), ('kTimeEditorAnimSource', 1109), ('caddyManipBase', 1110), ('kCaddyManipBase', 1110), ('polyCaddyManip', 1111), ('kPolyCaddyManip', 1111), ('polyModifierManipContainer', 1112), ('kPolyModifierManipContainer', 1112), ('polyRemesh', 1113), ('kPolyRemesh', 1113), ('polyContourProj', 1114), ('kPolyContourProj', 1114), ('contourProjectionManip', 1115), ('kContourProjectionManip', 1115), ('nodeGraphEditorInfo', 1116), ('kNodeGraphEditorInfo', 1116), ('nodeGraphEditorBookmarks', 1117), ('kNodeGraphEditorBookmarks', 1117), ('nodeGraphEditorBookmarkInfo', 1118), ('kNodeGraphEditorBookmarkInfo', 1118), ('pluginSkinCluster', 1119), ('kPluginSkinCluster', 1119), ('pluginGeometryFilter', 1120), ('kPluginGeometryFilter', 1120), ('pluginBlendShape', 1121), ('kPluginBlendShape', 1121), ('polyPassThru', 1122), ('kPolyPassThru', 1122), ('trackInfoManager', 1123), ('kTrackInfoManager', 1123), ('polyClean', 1124), ('kPolyClean', 1124), ('shapeEditorManager', 1125), ('kShapeEditorManager', 1125), ('oceanDeformer', 1126), ('kOceanDeformer', 1126), ('poseInterpolatorManager', 1127), ('kPoseInterpolatorManager', 1127), ('controllerTag', 1128), ('kControllerTag', 1128), ('reForm', 1129), ('kReForm', 1129), ('customEvaluatorClusterNode', 1130), ('kCustomEvaluatorClusterNode', 1130), ('polyCircularize', 1131), ('kPolyCircularize', 1131), ('arubaTesselate', 1132), ('kArubaTesselate', 1132), ('reorderUVSet', 1133), ('kReorderUVSet', 1133), ('ufeProxyTransform', 1134), ('kUfeProxyTransform', 1134), ('decomposeMatrix', 1135), ('kDecomposeMatrix', 1135), ('composeMatrix', 1136), ('kComposeMatrix', 1136), ('blendMatrix', 1137), ('kBlendMatrix', 1137), ('pickMatrix', 1138), ('kPickMatrix', 1138), ('aimMatrix', 1139), ('kAimMatrix', 1139), ('primitiveFalloff', 1140), ('kPrimitiveFalloff', 1140), ('blendFalloff', 1141), ('kBlendFalloff', 1141), ('uniformFalloff', 1142), ('kUniformFalloff', 1142), ('transferFalloff', 1143), ('kTransferFalloff', 1143), ('componentFalloff', 1144), ('kComponentFalloff', 1144), ('weightFunctionData', 1145), ('kWeightFunctionData', 1145), ('falloffEval', 1146), ('kFalloffEval', 1146), ('componentMatch', 1147), ('kComponentMatch', 1147), ('last', 1148), ('kLast', 1148)], multiKeys=True)"}},
  'MFnAirField': {'enums': {},
                  'invertibles': [('setComponentOnly', 'componentOnly'),
                                  ('setDirection', 'direction'),
                                  ('setEnableSpread', 'enableSpread'),
                                  ('setInheritRotation', 'inheritRotation'),
                                  ('setInheritVelocity', 'inheritVelocity'),
                                  ('setSpeed', 'speed'),
                                  ('setSpread', 'spread')],
                  'methods': {'className': [{'argInfo': {},
                                             'args': [],
                                             'defaults': {},
                                             'deprecated': False,
                                             'doc': 'Returns the name of this class.',
                                             'inArgs': [],
                                             'outArgs': [],
                                             'returnInfo': {'doc': 'Name of this class.',
                                                            'qualifiers': ['*'],
                                                            'type': 'char'},
                                             'returnType': 'char',
                                             'static': True,
                                             'typeQualifiers': {},
                                             'types': {}}],
                              'componentOnly': [{'argInfo': {},
                                                 'args': [],
                                                 'defaults': {},
                                                 'deprecated': False,
                                                 'doc': "Returns 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': {},
                                                 'types': {}}],
                              'direction': [{'argInfo': {},
                                             'args': [],
                                             'defaults': {},
                                             'deprecated': False,
                                             'doc': 'Returns 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': {},
                                             'types': {}}],
                              'enableSpread': [{'argInfo': {},
                                                'args': [],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': 'Returns 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': {},
                                                'types': {}}],
                              'inheritRotation': [{'argInfo': {},
                                                   'args': [],
                                                   'defaults': {},
                                                   'deprecated': False,
                                                   'doc': 'Returns 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': {},
                                                   'types': {}}],
                              'inheritVelocity': [{'argInfo': {},
                                                   'args': [],
                                                   'defaults': {},
                                                   'deprecated': False,
                                                   'doc': "Returns 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': {},
                                                   'types': {}}],
                              'setComponentOnly': [{'argInfo': {'enable': {'doc': 'Flag to enable or disable combination of attributes.',
                                                                           'type': 'bool'}},
                                                    'args': [('enable',
                                                              'bool',
                                                              'in')],
                                                    'defaults': {},
                                                    'deprecated': False,
                                                    'doc': 'Enables 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': {},
                                                    'types': {'enable': 'bool'}}],
                              'setDirection': [{'argInfo': {'airDirection': {'doc': 'A vector representing direction.',
                                                                             'type': 'MVector'}},
                                                'args': [('airDirection',
                                                          'MVector',
                                                          'in')],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': 'Sets 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': 'Enables 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': {},
                                                   'types': {'enable': 'bool'}}],
                              'setInheritRotation': [{'argInfo': {'enable': {'doc': 'Flag to enable or disable rotations effects.',
                                                                             'type': 'bool'}},
                                                      'args': [('enable',
                                                                'bool',
                                                                'in')],
                                                      'defaults': {},
                                                      'deprecated': False,
                                                      'doc': 'Enables 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': {},
                                                      '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': "Sets 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': {},
                                                      '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': 'Sets 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': {},
                                            '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': 'angular'}},
                                             'args': [('value',
                                                       'double',
                                                       'in')],
                                             'defaults': {},
                                             'deprecated': False,
                                             'doc': 'Sets 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': {},
                                             'types': {'value': 'double'}}],
                              'speed': [{'argInfo': {},
                                         'args': [],
                                         'defaults': {},
                                         'deprecated': False,
                                         'doc': 'Returns 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': {},
                                         'types': {}}],
                              'spread': [{'argInfo': {},
                                          'args': [],
                                          'defaults': {},
                                          'deprecated': False,
                                          'doc': 'Returns 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': 'angular'},
                                          'returnType': 'double',
                                          'static': False,
                                          'typeQualifiers': {},
                                          'types': {}}],
                              'type': [{'argInfo': {},
                                        'args': [],
                                        'defaults': {},
                                        'deprecated': False,
                                        'doc': 'Function set type',
                                        'inArgs': [],
                                        'outArgs': [],
                                        'returnInfo': {'doc': 'the class type.',
                                                       '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': [('setAmbientShade', 'ambientShade'),
                                      ('setCastSoftShadows', 'castSoftShadows'),
                                      ('setShadowRadius', 'shadowRadius')],
                      'methods': {'ambientShade': [{'argInfo': {},
                                                    'args': [],
                                                    'defaults': {},
                                                    'deprecated': False,
                                                    'doc': 'Retrieves 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': {},
                                                    'types': {}}],
                                  'castSoftShadows': [{'argInfo': {},
                                                       'args': [],
                                                       'defaults': {},
                                                       'deprecated': False,
                                                       'doc': 'Retrieves 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': {},
                                                       'types': {}}],
                                  'className': [{'argInfo': {},
                                                 'args': [],
                                                 'defaults': {},
                                                 'deprecated': False,
                                                 'doc': 'Returns the name of this class.',
                                                 'inArgs': [],
                                                 'outArgs': [],
                                                 'returnInfo': {'doc': 'Name of this class.',
                                                                'qualifiers': ['*'],
                                                                'type': 'char'},
                                                 'returnType': 'char',
                                                 'static': True,
                                                 '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': 'Creates 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': {},
                                              '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': 'Creates 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': {'parent': ['const',
                                                                            '&']},
                                              'types': {'UIvisible': 'bool',
                                                        'parent': 'MObject',
                                                        'wantTransform': 'bool'}}],
                                  'setAmbientShade': [{'argInfo': {'ambient_shade': {'doc': 'value to which the attribute will be set.',
                                                                                     'type': 'float'}},
                                                       'args': [('ambient_shade',
                                                                 'float',
                                                                 'in')],
                                                       'defaults': {},
                                                       'deprecated': False,
                                                       'doc': 'Sets 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': 'Sets 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': 'Sets 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': 'Retrieves 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': {},
                                                    'types': {}}],
                                  'type': [{'argInfo': {},
                                            'args': [],
                                            'defaults': {},
                                            'deprecated': False,
                                            'doc': 'Function set type',
                                            'inArgs': [],
                                            'outArgs': [],
                                            'returnInfo': {'doc': 'the class type.',
                                                           '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.',
                                                           'autoCustom': 'AutoCustom.',
                                                           'autoEase': 'AutoEase.',
                                                           'autoMix': 'AutoMix.',
                                                           '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.',
                                                           'kTangentAutoCustom': 'AutoCustom.',
                                                           'kTangentAutoEase': 'AutoEase.',
                                                           'kTangentAutoMix': 'AutoMix.',
                                                           '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, 'kTangentShared1': 19, 'kTangentShared2': 20, 'kTangentShared3': 21, 'kTangentShared4': 22, 'kTangentShared5': 23, 'kTangentShared6': 24, 'kTangentShared7': 25, 'kTangentShared8': 26, 'kTangentAutoMix': 27, 'kTangentAutoEase': 28, 'kTangentAutoCustom': 29, 'kTangentCustomStart': 64, 'kTangentCustomEnd': 32767, 'kTangentTypeCount': 32768})"}},
                   'invertibles': [('setInTangentType', 'inTangentType'),
                                   ('setIsBreakdown', 'isBreakdown'),
                                   ('setIsWeighted', 'isWeighted'),
                                   ('setOutTangentType', 'outTangentType'),
                                   ('setPostInfinityType', 'postInfinityType'),
                                   ('setPreInfinityType', 'preInfinityType'),
                                   ('setTangent', 'getTangent'),
                                   ('setTangentsLocked', 'tangentsLocked'),
                                   ('setTime', 'time'),
                                   ('setUnitlessInput', 'unitlessInput'),
                                   ('setValue', 'value'),
                                   ('setWeightsLocked', 'weightsLocked')],
                   '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': 'Adds 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': 'uint'},
                                           'returnType': 'uint',
                                           'static': False,
                                           'typeQualifiers': {'change': ['*'],
                                                              'time': ['const',
                                                                       '&']},
                                           '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': 'Adds 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': 'uint'},
                                           'returnType': 'uint',
                                           'static': False,
                                           'typeQualifiers': {'change': ['*'],
                                                              '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': 'Adds 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': 'uint'},
                                           'returnType': 'uint',
                                           'static': False,
                                           'typeQualifiers': {'change': ['*']},
                                           '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': 'Adds 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': 'uint'},
                                           'returnType': 'uint',
                                           'static': False,
                                           'typeQualifiers': {'change': ['*'],
                                                              'timeValue': ['const',
                                                                            '&']},
                                           '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': 'Adds 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',
                                                                            '&']},
                                                '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': 'Adds 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': ['*'],
                                                                   'time': ['const',
                                                                            '&']},
                                                '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': 'Add 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': ['*'],
                                                               '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': 'Add 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': ['*'],
                                                                           'tangentInTypeArray': ['*'],
                                                                           'tangentInXArray': ['*'],
                                                                           'tangentInYArray': ['*'],
                                                                           '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': 'Returns the animCurve type',
                                                  'inArgs': [],
                                                  'outArgs': [],
                                                  'returnInfo': {'doc': 'The animCurve type.',
                                                                 'qualifiers': [],
                                                                 'type': ('MFnAnimCurve',
                                                                          'AnimCurveType')},
                                                  'returnType': ('MFnAnimCurve',
                                                                 'AnimCurveType'),
                                                  'static': False,
                                                  'typeQualifiers': {},
                                                  'types': {}}],
                               'className': [{'argInfo': {},
                                              'args': [],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': 'Returns the name of this class.',
                                              'inArgs': [],
                                              'outArgs': [],
                                              'returnInfo': {'doc': 'Name of this class.',
                                                             'qualifiers': ['*'],
                                                             'type': 'char'},
                                              'returnType': 'char',
                                              'static': True,
                                              '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': 'Creates 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': {'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': 'Creates 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': {'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': 'Creates 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': {'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': 'Creates 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': {'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': 'Creates 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': {'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': 'Determines 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': {'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': 'Determines 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': 'Determines 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': 'Determines 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': 'Determines 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': 'Determines 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': {'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': 'Determines 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': {'index': ['unsigned',
                                                                      '&']},
                                         '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': 'Determines 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': 'uint'},
                                                'returnType': 'uint',
                                                'static': False,
                                                'typeQualifiers': {'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': 'Determines 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': 'uint'},
                                                'returnType': 'uint',
                                                'static': False,
                                                'typeQualifiers': {},
                                                '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': "Determines 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': {'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': 'Determines 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': ['&'],
                                                                  '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': 'Determines 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': {'index': ['unsigned']},
                                                  'types': {'index': 'uint'}}],
                               'insertKey': [{'argInfo': {'breakdown': {'doc': 'Whether the new key is a breakdown key',
                                                                        'type': 'bool'},
                                                          'change': {'doc': 'Optional cache to store undo/redo information.',
                                                                     'type': 'MAnimCurveChange'},
                                                          'time': {'doc': 'Time to insert the key',
                                                                   'type': 'MTime'}},
                                              'args': [('time', 'MTime', 'in'),
                                                       ('breakdown',
                                                        'bool',
                                                        'in'),
                                                       ('change',
                                                        'MAnimCurveChange',
                                                        'in')],
                                              'defaults': {'breakdown': False,
                                                           'change': None},
                                              'deprecated': False,
                                              'doc': 'Inserts a key at the specified time adjusting neighboring tangents to maintain curve shape. This method is the API equivalent to setKeyframe -insert.',
                                              'inArgs': ['time',
                                                         'breakdown',
                                                         'change'],
                                              'outArgs': [],
                                              'returnInfo': {'doc': '',
                                                             'qualifiers': [],
                                                             'type': 'uint'},
                                              'returnType': 'uint',
                                              'static': False,
                                              'typeQualifiers': {'change': ['*'],
                                                                 'time': ['const',
                                                                          '&']},
                                              'types': {'breakdown': 'bool',
                                                        'change': 'MAnimCurveChange',
                                                        'time': 'MTime'}}],
                               'isBreakdown': [{'argInfo': {'index': {'doc': "The key's index",
                                                                      'type': 'uint'}},
                                                'args': [('index',
                                                          'uint',
                                                          'in')],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': 'Determines 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': {'index': ['unsigned']},
                                                'types': {'index': 'uint'}}],
                               'isStatic': [{'argInfo': {},
                                             'args': [],
                                             'defaults': {},
                                             'deprecated': False,
                                             'doc': 'Determines 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': {},
                                             'types': {}}],
                               'isTimeInput': [{'argInfo': {},
                                                'args': [],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': 'Determines 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': {},
                                                'types': {}}],
                               'isUnitlessInput': [{'argInfo': {},
                                                    'args': [],
                                                    'defaults': {},
                                                    'deprecated': False,
                                                    'doc': 'Determines 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': {},
                                                    'types': {}}],
                               'isWeighted': [{'argInfo': {},
                                               'args': [],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': 'Determines 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': {},
                                               'types': {}}],
                               'numKeyframes': [{'argInfo': {},
                                                 'args': [],
                                                 'defaults': {},
                                                 'deprecated': True,
                                                 'doc': 'This method is obsolete. [from before Maya 2016]',
                                                 'inArgs': [],
                                                 'outArgs': [],
                                                 'returnInfo': {'doc': 'Number of keys on the Anim Curve Node',
                                                                'qualifiers': [],
                                                                'type': 'uint'},
                                                 'returnType': 'uint',
                                                 'static': False,
                                                 'typeQualifiers': {},
                                                 'types': {}}],
                               'numKeys': [{'argInfo': {},
                                            'args': [],
                                            'defaults': {},
                                            'deprecated': False,
                                            'doc': 'Determines the number of keys on the Anim Curve Node.',
                                            'inArgs': [],
                                            'outArgs': [],
                                            'returnInfo': {'doc': 'Number of keys on the Anim Curve Node',
                                                           'qualifiers': [],
                                                           'type': 'uint'},
                                            'returnType': 'uint',
                                            'static': False,
                                            'typeQualifiers': {},
                                            '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': 'Determines 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': {'index': ['unsigned']},
                                                   'types': {'index': 'uint'}}],
                               'postInfinityType': [{'argInfo': {},
                                                     'args': [],
                                                     'defaults': {},
                                                     'deprecated': False,
                                                     'doc': 'Determines 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': {},
                                                     'types': {}}],
                               'preInfinityType': [{'argInfo': {},
                                                    'args': [],
                                                    'defaults': {},
                                                    'deprecated': False,
                                                    'doc': 'Determines 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': {},
                                                    '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': 'Removes 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': 'Set 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': ['*'],
                                                                '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': 'Sets 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']},
                                                     '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': 'Sets 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']},
                                                   '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': 'Sets 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': ['*']},
                                                  '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': 'Sets 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']},
                                                      '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': 'Set 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': ['*']},
                                                        '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': 'Set 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': ['*']},
                                                       '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': 'Sets 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': ['*'],
                                                                  'index': ['unsigned']},
                                               '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': 'Sets 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': ['*'],
                                                                  'index': ['unsigned']},
                                               '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': 'Sets the tangent types for multiple keys.',
                                                    'inArgs': ['indexArray',
                                                               'inTangentType',
                                                               'outTangentType',
                                                               'change'],
                                                    'outArgs': [],
                                                    'returnInfo': {'doc': '',
                                                                   'qualifiers': [],
                                                                   'type': None},
                                                    'returnType': None,
                                                    'static': False,
                                                    'typeQualifiers': {'change': ['*']},
                                                    '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': 'Lock 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']},
                                                      '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': 'Sets 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': 'Sets 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']},
                                                     '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': 'Sets 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']},
                                             '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': 'Set 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': ['*'],
                                                                 'index': ['unsigned']},
                                              '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': 'Lock 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']},
                                                     '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': 'Determines 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': {'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': 'Determines 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': {'index': ['unsigned']},
                                         'types': {'index': 'uint'}}],
                               'timedAnimCurveTypeForPlug': [{'argInfo': {'plug': {'doc': 'plug',
                                                                                   'type': 'MPlug'}},
                                                              'args': [('plug',
                                                                        'MPlug',
                                                                        'in')],
                                                              'defaults': {},
                                                              'deprecated': False,
                                                              'doc': 'Returns 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': {'plug': ['&']},
                                                              'types': {'plug': 'MPlug'}}],
                               'type': [{'argInfo': {},
                                         'args': [],
                                         'defaults': {},
                                         'deprecated': False,
                                         'doc': 'Function set type',
                                         'inArgs': [],
                                         'outArgs': [],
                                         'returnInfo': {'doc': 'the class type.',
                                                        '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': 'Returns 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': {'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': 'Determines 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': {'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': 'Determines 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': {'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': 'Determines 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': {'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), ('shared1', 19), ('kTangentShared1', 19), ('shared2', 20), ('kTangentShared2', 20), ('shared3', 21), ('kTangentShared3', 21), ('shared4', 22), ('kTangentShared4', 22), ('shared5', 23), ('kTangentShared5', 23), ('shared6', 24), ('kTangentShared6', 24), ('shared7', 25), ('kTangentShared7', 25), ('shared8', 26), ('kTangentShared8', 26), ('autoMix', 27), ('kTangentAutoMix', 27), ('autoEase', 28), ('kTangentAutoEase', 28), ('autoCustom', 29), ('kTangentAutoCustom', 29), ('customStart', 64), ('kTangentCustomStart', 64), ('customEnd', 32767), ('kTangentCustomEnd', 32767), ('typeCount', 32768), ('kTangentTypeCount', 32768)], 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': [('setAnisotropicReflectivity',
                                           'anisotropicReflectivity'),
                                          ('setCorrelationX', 'correlationX'),
                                          ('setCorrelationY', 'correlationY'),
                                          ('setRefractiveIndex',
                                           'refractiveIndex'),
                                          ('setRotateAngle', 'rotateAngle'),
                                          ('setRoughness', 'roughness'),
                                          ('setTangentUCamera',
                                           'tangentUCamera'),
                                          ('setTangentVCamera',
                                           'tangentVCamera')],
                          'methods': {'anisotropicReflectivity': [{'argInfo': {},
                                                                   'args': [],
                                                                   'defaults': {},
                                                                   'deprecated': False,
                                                                   'doc': 'Retrieves 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': {},
                                                                   'types': {}}],
                                      'className': [{'argInfo': {},
                                                     'args': [],
                                                     'defaults': {},
                                                     'deprecated': False,
                                                     'doc': 'Returns the name of this class.',
                                                     'inArgs': [],
                                                     'outArgs': [],
                                                     'returnInfo': {'doc': 'Name of this class.',
                                                                    'qualifiers': ['*'],
                                                                    'type': 'char'},
                                                     'returnType': 'char',
                                                     'static': True,
                                                     'typeQualifiers': {},
                                                     'types': {}}],
                                      'correlationX': [{'argInfo': {},
                                                        'args': [],
                                                        'defaults': {},
                                                        'deprecated': False,
                                                        'doc': 'Retrieves 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': {},
                                                        'types': {}}],
                                      'correlationY': [{'argInfo': {},
                                                        'args': [],
                                                        'defaults': {},
                                                        'deprecated': False,
                                                        'doc': 'Retrieves 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': {},
                                                        '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': 'Creates 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': {},
                                                  'types': {'UIvisible': 'bool'}}],
                                      'refractiveIndex': [{'argInfo': {},
                                                           'args': [],
                                                           'defaults': {},
                                                           'deprecated': False,
                                                           'doc': 'Retrieves 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': {},
                                                           'types': {}}],
                                      'rotateAngle': [{'argInfo': {},
                                                       'args': [],
                                                       'defaults': {},
                                                       'deprecated': False,
                                                       'doc': 'Retrieves 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': {},
                                                       'types': {}}],
                                      'roughness': [{'argInfo': {},
                                                     'args': [],
                                                     'defaults': {},
                                                     'deprecated': False,
                                                     'doc': 'Retrieves 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': {},
                                                     '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': 'Sets 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': 'Sets 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': 'Sets 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': 'Sets 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': 'Sets 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': 'Sets 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': 'Sets 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': 'Sets 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': 'Retrieves 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': {},
                                                          'types': {}}],
                                      'tangentVCamera': [{'argInfo': {},
                                                          'args': [],
                                                          'defaults': {},
                                                          'deprecated': False,
                                                          'doc': 'Retrieves 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': {},
                                                          'types': {}}],
                                      'type': [{'argInfo': {},
                                                'args': [],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': 'Function set type',
                                                'inArgs': [],
                                                'outArgs': [],
                                                'returnInfo': {'doc': 'the class type.',
                                                               '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': 'Returns the name of this class.',
                                              'inArgs': [],
                                              'outArgs': [],
                                              'returnInfo': {'doc': 'Name of this class.',
                                                             'qualifiers': ['*'],
                                                             'type': 'char'},
                                              'returnType': 'char',
                                              'static': True,
                                              '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': 'Creates 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': {},
                                           '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': 'Creates 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': {'parent': ['const',
                                                                         '&']},
                                           'types': {'UIvisible': 'bool',
                                                     'parent': 'MObject',
                                                     'wantTransform': 'bool'}}],
                               'type': [{'argInfo': {},
                                         'args': [],
                                         'defaults': {},
                                         'deprecated': False,
                                         'doc': 'Function set type',
                                         'inArgs': [],
                                         'outArgs': [],
                                         'returnInfo': {'doc': 'the class type.',
                                                        'qualifiers': [],
                                                        'type': ('MFn',
                                                                 'Type')},
                                         'returnType': ('MFn', 'Type'),
                                         'static': False,
                                         'typeQualifiers': {},
                                         'types': {}}]},
                   'pymelEnums': {}},
  'MFnArrayAttrsData': {'enums': {'Type': {'valueDocs': {'doubleArray': 'use doubleArray() method to extract the attribute array.',
                                                         'intArray': 'use intArray() method to extract the attribute array.',
                                                         'kDoubleArray': 'use doubleArray() method to extract the attribute array.',
                                                         'kIntArray': 'use intArray() method to extract the attribute array.',
                                                         'kStringArray': 'use stringArray() method to extract the attribute array.',
                                                         'kVectorArray': 'use vectorArray() method to extract the attribute array.',
                                                         'stringArray': 'use stringArray() method to extract the attribute array.',
                                                         'vectorArray': 'use vectorArray() method to extract the attribute array.'},
                                           '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': 'Check 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': {'arrayType': ['&'],
                                                                            'name': ['const']},
                                                         'types': {'arrayType': ('MFnArrayAttrsData',
                                                                                 'Type'),
                                                                   'name': 'MString'}}],
                                    'className': [{'argInfo': {},
                                                   'args': [],
                                                   'defaults': {},
                                                   'deprecated': False,
                                                   'doc': 'Returns the name of this class.',
                                                   'inArgs': [],
                                                   'outArgs': [],
                                                   'returnInfo': {'doc': 'Name of this class.',
                                                                  'qualifiers': ['*'],
                                                                  'type': 'char'},
                                                   'returnType': 'char',
                                                   'static': True,
                                                   'typeQualifiers': {},
                                                   'types': {}}],
                                    'clear': [{'argInfo': {},
                                               'args': [],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': 'Clear 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': 'Returns the number of attribute arrays.',
                                               'inArgs': [],
                                               'outArgs': [],
                                               'returnInfo': {'doc': 'The number or arrays',
                                                              'qualifiers': [],
                                                              'type': 'uint'},
                                               'returnType': 'uint',
                                               'static': False,
                                               'typeQualifiers': {},
                                               'types': {}}],
                                    'create': [{'argInfo': {},
                                                'args': [],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': 'Create 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': {},
                                                'types': {}}],
                                    'doubleArray': [{'argInfo': {'name': {'doc': 'the name of the array to edit or create.',
                                                                          'type': 'MString'}},
                                                     'args': [('name',
                                                               'MString',
                                                               'in')],
                                                     'defaults': {},
                                                     'deprecated': False,
                                                     'doc': 'Return 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': {'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': 'Return 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': {'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': 'Return 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': {'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': 'Return 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': {'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': 'Return 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': {'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': 'Return 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': {'name': ['const']},
                                                  'types': {'name': 'MString'}}],
                                    'list': [{'argInfo': {},
                                              'args': [],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': 'Returns 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': {},
                                              'types': {}}],
                                    'stringArray': [{'argInfo': {'name': {'doc': 'the name of the array to edit or create.',
                                                                          'type': 'MString'}},
                                                     'args': [('name',
                                                               'MString',
                                                               'in')],
                                                     'defaults': {},
                                                     'deprecated': False,
                                                     'doc': 'Return 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': {'name': ['const']},
                                                     'types': {'name': 'MString'}}],
                                    'type': [{'argInfo': {},
                                              'args': [],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': 'Function set type',
                                              'inArgs': [],
                                              'outArgs': [],
                                              'returnInfo': {'doc': 'the class type.',
                                                             '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': 'Return 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': {'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': 'Activate 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': 'Activate 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': 'Determines 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': {},
                                               'types': {}}],
                              'canRepApplyEdits': [{'argInfo': {'representation': {'doc': 'Representation to query.',
                                                                                   'type': 'MString'}},
                                                    'args': [('representation',
                                                              'MString',
                                                              'in')],
                                                    'defaults': {},
                                                    'deprecated': False,
                                                    'doc': 'Determines 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',
                                                                                          '&']},
                                                    'types': {'representation': 'MString'}}],
                              'className': [{'argInfo': {},
                                             'args': [],
                                             'defaults': {},
                                             'deprecated': False,
                                             'doc': 'Returns the name of this class.',
                                             'inArgs': [],
                                             'outArgs': [],
                                             'returnInfo': {'doc': 'Name of this class.',
                                                            'qualifiers': ['*'],
                                                            'type': 'char'},
                                             'returnType': 'char',
                                             'static': True,
                                             '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': 'Create 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',
                                                                                     '&'],
                                                                           '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': 'Create 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',
                                                                                              '&'],
                                                                           'type': ['const',
                                                                                    '&'],
                                                                           'undoRedo': ['*']},
                                                        'types': {'input': 'MString',
                                                                  'representation': 'MString',
                                                                  'type': 'MString',
                                                                  'undoRedo': 'MDagModifier'}}],
                              'deleteAllRepresentations': [{'argInfo': {},
                                                            'args': [],
                                                            'defaults': {},
                                                            'deprecated': False,
                                                            'doc': 'Delete 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': 'Delete 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': 'Get 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': {},
                                                           'types': {}}],
                              'getActive': [{'argInfo': {},
                                             'args': [],
                                             'defaults': {},
                                             'deprecated': False,
                                             'doc': 'Get 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': {},
                                             'types': {}}],
                              'getInitialRep': [{'argInfo': {},
                                                 'args': [],
                                                 'defaults': {},
                                                 'deprecated': True,
                                                 'doc': 'This method is obsolete. [as of Maya 2019]',
                                                 'inArgs': [],
                                                 'outArgs': [],
                                                 'returnInfo': {'doc': 'The initial representation to use, if any, else an empty string.',
                                                                'qualifiers': [],
                                                                'type': 'MString'},
                                                 'returnType': 'MString',
                                                 'static': False,
                                                 'typeQualifiers': {},
                                                 'types': {}},
                                                {'argInfo': {'hasInitialRep': {'doc': 'Return whether or not we have an initial representation',
                                                                               'type': 'bool'}},
                                                 'args': [('hasInitialRep',
                                                           'bool',
                                                           'out')],
                                                 'defaults': {},
                                                 'deprecated': False,
                                                 'doc': 'Get 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': ['&']},
                                                 'types': {'hasInitialRep': 'bool'}}],
                              'getParentAssembly': [{'argInfo': {},
                                                     'args': [],
                                                     'defaults': {},
                                                     'deprecated': False,
                                                     'doc': 'Return 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': {},
                                                     'types': {}}],
                              'getRepLabel': [{'argInfo': {'representation': {'doc': 'Representation whose label must be returned.',
                                                                              'type': 'MString'}},
                                               'args': [('representation',
                                                         'MString',
                                                         'in')],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': 'Get 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',
                                                                                     '&']},
                                               'types': {'representation': 'MString'}}],
                              'getRepNamespace': [{'argInfo': {},
                                                   'args': [],
                                                   'defaults': {},
                                                   'deprecated': False,
                                                   'doc': 'Get 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': {},
                                                   'types': {}}],
                              'getRepType': [{'argInfo': {'representation': {'doc': 'Representation whose type must be returned.',
                                                                             'type': 'MString'}},
                                              'args': [('representation',
                                                        'MString',
                                                        'in')],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': 'Get 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',
                                                                                    '&']},
                                              'types': {'representation': 'MString'}}],
                              'getRepresentations': [{'argInfo': {},
                                                      'args': [],
                                                      'defaults': {},
                                                      'deprecated': False,
                                                      'doc': 'Returns 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': {},
                                                      'types': {}}],
                              'getSubAssemblies': [{'argInfo': {},
                                                    'args': [],
                                                    'defaults': {},
                                                    'deprecated': False,
                                                    'doc': 'Returns 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': {},
                                                    'types': {}}],
                              'getTopLevelAssemblies': [{'argInfo': {},
                                                         'args': [],
                                                         'defaults': {},
                                                         'deprecated': False,
                                                         'doc': 'Returns a list containing top-level assemblies. These are assemblies that are not nested inside another assembly.',
                                                         'inArgs': [],
                                                         'outArgs': [],
                                                         'returnInfo': {'doc': 'Array of top-level assemblies.',
                                                                        'qualifiers': [],
                                                                        'type': 'MObjectArray'},
                                                         'returnType': 'MObjectArray',
                                                         'static': True,
                                                         'typeQualifiers': {},
                                                         'types': {}}],
                              'handlesAddEdits': [{'argInfo': {},
                                                   'args': [],
                                                   'defaults': {},
                                                   'deprecated': False,
                                                   'doc': 'Determines 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': {},
                                                   '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': 'Import 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',
                                                                              '&'],
                                                                 'nameSpace': ['const',
                                                                               '*'],
                                                                 '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': 'Determines 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',
                                                                                  '&']},
                                            'types': {'representation': 'MString'}}],
                              'isTopLevel': [{'argInfo': {},
                                              'args': [],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': 'Returns 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': {},
                                              'types': {}}],
                              'postLoad': [{'argInfo': {},
                                            'args': [],
                                            'defaults': {},
                                            'deprecated': False,
                                            'doc': 'Method to initialize assemblies after their creation.',
                                            'inArgs': [],
                                            'outArgs': [],
                                            'returnInfo': {'doc': '',
                                                           'qualifiers': [],
                                                           'type': None},
                                            'returnType': None,
                                            'static': False,
                                            'typeQualifiers': {},
                                            'types': {}}],
                              'repTypes': [{'argInfo': {},
                                            'args': [],
                                            'defaults': {},
                                            'deprecated': False,
                                            'doc': 'Return 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': {},
                                            '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': 'Change 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': 'Rename a representation.',
                                              'inArgs': ['representation',
                                                         'newName'],
                                              'outArgs': [],
                                              'returnInfo': {'doc': 'New representation name.',
                                                             'qualifiers': [],
                                                             'type': 'MString'},
                                              'returnType': 'MString',
                                              'static': False,
                                              'typeQualifiers': {'newName': ['const',
                                                                             '&'],
                                                                 'representation': ['const',
                                                                                    '&']},
                                              'types': {'newName': 'MString',
                                                        'representation': 'MString'}}],
                              'supportsEdits': [{'argInfo': {},
                                                 'args': [],
                                                 'defaults': {},
                                                 'deprecated': False,
                                                 'doc': 'Does this assembly support edit tracking?',
                                                 'inArgs': [],
                                                 'outArgs': [],
                                                 'returnInfo': {'doc': 'Whether the assembly supports tracking of edits on its nodes',
                                                                'qualifiers': [],
                                                                'type': 'bool'},
                                                 'returnType': 'bool',
                                                 'static': False,
                                                 'typeQualifiers': {},
                                                 'types': {}}],
                              'supportsMemberChanges': [{'argInfo': {},
                                                         'args': [],
                                                         'defaults': {},
                                                         'deprecated': False,
                                                         'doc': 'Can members of the assembly be changed?',
                                                         'inArgs': [],
                                                         'outArgs': [],
                                                         'returnInfo': {'doc': 'Whether the assembly supports changes to its nodes',
                                                                        'qualifiers': [],
                                                                        'type': 'bool'},
                                                         'returnType': 'bool',
                                                         'static': False,
                                                         'typeQualifiers': {},
                                                         'types': {}}],
                              'type': [{'argInfo': {},
                                        'args': [],
                                        'defaults': {},
                                        'deprecated': False,
                                        'doc': 'Function set type',
                                        'inArgs': [],
                                        'outArgs': [],
                                        'returnInfo': {'doc': 'the class type.',
                                                       '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': [('setAffectsAppearance',
                                    'affectsAppearance'),
                                   ('setAffectsWorldSpace',
                                    'isAffectsWorldSpace'),
                                   ('setArray', 'isArray'),
                                   ('setCached', 'isCached'),
                                   ('setConnectable', 'isConnectable'),
                                   ('setDisconnectBehavior',
                                    'disconnectBehavior'),
                                   ('setHidden', 'isHidden'),
                                   ('setIndeterminant', 'isIndeterminant'),
                                   ('setIndexMatters', 'indexMatters'),
                                   ('setInternal', 'internal'),
                                   ('setKeyable', 'isKeyable'),
                                   ('setProxyAttribute', 'isProxyAttribute'),
                                   ('setReadable', 'isReadable'),
                                   ('setRenderSource', 'isRenderSource'),
                                   ('setStorable', 'isStorable'),
                                   ('setUsedAsColor', 'isUsedAsColor'),
                                   ('setUsedAsFilename', 'isUsedAsFilename'),
                                   ('setUsesArrayDataBuilder',
                                    'usesArrayDataBuilder'),
                                   ('setWorldSpace', 'isWorldSpace'),
                                   ('setWritable', 'isWritable')],
                   'methods': {'accepts': [{'argInfo': {'type': {'doc': 'data type',
                                                                 'type': ('MFnData',
                                                                          'Type')}},
                                            'args': [('type',
                                                      ('MFnData', 'Type'),
                                                      'in')],
                                            'defaults': {},
                                            'deprecated': False,
                                            'doc': 'Returns 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': {},
                                            'types': {'type': ('MFnData',
                                                               'Type')}},
                                           {'argInfo': {'id': {'doc': 'data type id',
                                                               'type': 'MTypeId'}},
                                            'args': [('id', 'MTypeId', 'in')],
                                            'defaults': {},
                                            'deprecated': False,
                                            'doc': 'Returns 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': {'id': ['const',
                                                                      '&']},
                                            'types': {'id': 'MTypeId'}}],
                               'acceptsAttribute': [{'argInfo': {'attr': {'doc': 'attribute',
                                                                          'type': 'MFnAttribute'}},
                                                     'args': [('attr',
                                                               'MFnAttribute',
                                                               'in')],
                                                     'defaults': {},
                                                     'deprecated': False,
                                                     'doc': 'Returns 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': {'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': 'Add the attribute to the named category.',
                                                  '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': 'Returns 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': {},
                                                      'types': {}}],
                               'className': [{'argInfo': {},
                                              'args': [],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': 'Returns the name of this class.',
                                              'inArgs': [],
                                              'outArgs': [],
                                              'returnInfo': {'doc': 'Name of this class.',
                                                             'qualifiers': ['*'],
                                                             'type': 'char'},
                                              'returnType': 'char',
                                              'static': True,
                                              'typeQualifiers': {},
                                              'types': {}}],
                               'disconnectBehavior': [{'argInfo': {},
                                                       'args': [],
                                                       'defaults': {},
                                                       'deprecated': False,
                                                       'doc': 'Returns 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': {},
                                                       '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': 'Returns 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': {},
                                                  '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': 'Get all of the categories to which this attribute belongs.',
                                                  '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': 'Check to see if the attribute belongs to the named category.',
                                                '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': 'Determines 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': {},
                                                 'types': {}}],
                               'internal': [{'argInfo': {},
                                             'args': [],
                                             'defaults': {},
                                             'deprecated': False,
                                             'doc': 'Returns 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': {},
                                             'types': {}}],
                               'isAffectsWorldSpace': [{'argInfo': {},
                                                        'args': [],
                                                        'defaults': {},
                                                        'deprecated': False,
                                                        'doc': 'Returns 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': {},
                                                        'types': {}}],
                               'isArray': [{'argInfo': {},
                                            'args': [],
                                            'defaults': {},
                                            'deprecated': False,
                                            'doc': 'Returns 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': {},
                                            'types': {}}],
                               'isCached': [{'argInfo': {},
                                             'args': [],
                                             'defaults': {},
                                             'deprecated': False,
                                             'doc': "Returns 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': {},
                                             'types': {}}],
                               'isChannelBoxFlagSet': [{'argInfo': {},
                                                        'args': [],
                                                        'defaults': {},
                                                        'deprecated': False,
                                                        'doc': 'Returns 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': {},
                                                        'types': {}}],
                               'isConnectable': [{'argInfo': {},
                                                  'args': [],
                                                  'defaults': {},
                                                  'deprecated': False,
                                                  'doc': 'Returns 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': {},
                                                  'types': {}}],
                               'isDynamic': [{'argInfo': {},
                                              'args': [],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': 'Returns 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': {},
                                              'types': {}}],
                               'isExtension': [{'argInfo': {},
                                                'args': [],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': 'Returns 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': {},
                                                'types': {}}],
                               'isHidden': [{'argInfo': {},
                                             'args': [],
                                             'defaults': {},
                                             'deprecated': False,
                                             'doc': 'Returns 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': {},
                                             'types': {}}],
                               'isIndeterminant': [{'argInfo': {},
                                                    'args': [],
                                                    'defaults': {},
                                                    'deprecated': False,
                                                    'doc': 'Returns 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': {},
                                                    'types': {}}],
                               'isKeyable': [{'argInfo': {},
                                              'args': [],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': 'Returns 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': {},
                                              'types': {}}],
                               'isProxyAttribute': [{'argInfo': {},
                                                     'args': [],
                                                     'defaults': {},
                                                     'deprecated': False,
                                                     'doc': 'Returns true if this attribute is a proxy attribute.',
                                                     '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': {},
                                                     'types': {}}],
                               'isReadable': [{'argInfo': {},
                                               'args': [],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': 'Returns 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': {},
                                               'types': {}}],
                               'isRenderSource': [{'argInfo': {},
                                                   'args': [],
                                                   'defaults': {},
                                                   'deprecated': False,
                                                   'doc': 'Returns 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': {},
                                                   'types': {}}],
                               'isStorable': [{'argInfo': {},
                                               'args': [],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': 'Returns 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': {},
                                               'types': {}}],
                               'isUsedAsColor': [{'argInfo': {},
                                                  'args': [],
                                                  'defaults': {},
                                                  'deprecated': False,
                                                  'doc': 'Returns 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': {},
                                                  'types': {}}],
                               'isUsedAsFilename': [{'argInfo': {},
                                                     'args': [],
                                                     'defaults': {},
                                                     'deprecated': False,
                                                     'doc': 'Returns 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': {},
                                                     'types': {}}],
                               'isWorldSpace': [{'argInfo': {},
                                                 'args': [],
                                                 'defaults': {},
                                                 'deprecated': False,
                                                 'doc': 'Returns 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': {},
                                                 'types': {}}],
                               'isWritable': [{'argInfo': {},
                                               'args': [],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': 'Returns 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': {},
                                               'types': {}}],
                               'name': [{'argInfo': {},
                                         'args': [],
                                         'defaults': {},
                                         'deprecated': False,
                                         'doc': 'Returns 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': {},
                                         'types': {}}],
                               'parent': [{'argInfo': {},
                                           'args': [],
                                           'defaults': {},
                                           'deprecated': False,
                                           'doc': 'Get the parent of this attribute, if it has one.',
                                           'inArgs': [],
                                           'outArgs': [],
                                           'returnInfo': {'doc': 'The parent attribute',
                                                          'qualifiers': [],
                                                          'type': 'MObject'},
                                           'returnType': 'MObject',
                                           'static': False,
                                           'typeQualifiers': {},
                                           'types': {}}],
                               'removeFromCategory': [{'argInfo': {'category': {'doc': 'Category from which the attribute is to be removed',
                                                                                'type': 'MString'}},
                                                       'args': [('category',
                                                                 'MString',
                                                                 'in')],
                                                       'defaults': {},
                                                       'deprecated': False,
                                                       'doc': 'Remove the attribute from the named category.',
                                                       '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': 'Sets 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': {},
                                                         'types': {'state': 'bool'}}],
                               'setAffectsWorldSpace': [{'argInfo': {'state': {'doc': 'whether the attribute should affect worldspace',
                                                                               'type': 'bool'}},
                                                         'args': [('state',
                                                                   'bool',
                                                                   'in')],
                                                         'defaults': {},
                                                         'deprecated': False,
                                                         'doc': 'Sets 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': {},
                                                         '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': 'Sets 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': {},
                                             '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': "Sets 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': {},
                                              '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': 'Sets 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': {},
                                                  'types': {'state': 'bool'}}],
                               'setConnectable': [{'argInfo': {'state': {'doc': 'whether the attribute is to be connectable',
                                                                         'type': 'bool'}},
                                                   'args': [('state',
                                                             'bool',
                                                             'in')],
                                                   'defaults': {},
                                                   'deprecated': False,
                                                   'doc': 'Sets 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': {},
                                                   'types': {'state': 'bool'}}],
                               'setDisconnectBehavior': [{'argInfo': {'behavior': {'doc': 'the new disconnect behavior',
                                                                                   'type': ('MFnAttribute',
                                                                                            'DisconnectBehavior')}},
                                                          'args': [('behavior',
                                                                    ('MFnAttribute',
                                                                     'DisconnectBehavior'),
                                                                    'in')],
                                                          'defaults': {},
                                                          'deprecated': False,
                                                          'doc': 'Sets 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': {},
                                                          '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': 'Sets 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': {},
                                              'types': {'state': 'bool'}}],
                               'setIndeterminant': [{'argInfo': {'state': {'doc': 'whether the attribute indeterminant',
                                                                           'type': 'bool'}},
                                                     'args': [('state',
                                                               'bool',
                                                               'in')],
                                                     'defaults': {},
                                                     'deprecated': False,
                                                     'doc': 'Sets 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': {},
                                                     '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': 'If 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': {},
                                                    'types': {'state': 'bool'}}],
                               'setInternal': [{'argInfo': {'state': {'doc': 'whether the attribute uses internal data',
                                                                      'type': 'bool'}},
                                                'args': [('state',
                                                          'bool',
                                                          'in')],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': "The 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': {},
                                                'types': {'state': 'bool'}}],
                               'setKeyable': [{'argInfo': {'state': {'doc': 'whether the attribute is to be keyable',
                                                                     'type': 'bool'}},
                                               'args': [('state',
                                                         'bool',
                                                         'in')],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': 'Sets 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': {},
                                               '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': 'Sets 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': 'Sets whether this attribute is a proxy attribute.',
                                                      'inArgs': ['state'],
                                                      'inverse': ('isProxyAttribute',
                                                                  True),
                                                      'outArgs': [],
                                                      'returnInfo': {'doc': '',
                                                                     'qualifiers': [],
                                                                     'type': None},
                                                      'returnType': None,
                                                      'static': False,
                                                      'typeQualifiers': {},
                                                      'types': {'state': 'bool'}}],
                               'setReadable': [{'argInfo': {'state': {'doc': 'whether the attribute is to be readable',
                                                                      'type': 'bool'}},
                                                'args': [('state',
                                                          'bool',
                                                          'in')],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': 'Sets 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': {},
                                                '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': 'Sets 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': {},
                                                    'types': {'state': 'bool'}}],
                               'setStorable': [{'argInfo': {'state': {'doc': 'whether the attribute is to be storable',
                                                                      'type': 'bool'}},
                                                'args': [('state',
                                                          'bool',
                                                          'in')],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': 'Sets 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': {},
                                                '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': 'Sets 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': {},
                                                   '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': 'Sets 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': {},
                                                      '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': 'Sets 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': {},
                                                            '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': 'Sets 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': {},
                                                  'types': {'state': 'bool'}}],
                               'setWritable': [{'argInfo': {'state': {'doc': 'whether the attribute is to be writable',
                                                                      'type': 'bool'}},
                                                'args': [('state',
                                                          'bool',
                                                          'in')],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': 'Sets whether this attribute should be writable. If an attribute is writable, then it can be used as the destination in a dependency graph connection.',
                                                'inArgs': ['state'],
                                                'inverse': ('isWritable', True),
                                                'outArgs': [],
                                                'returnInfo': {'doc': '',
                                                               'qualifiers': [],
                                                               'type': None},
                                                'returnType': None,
                                                'static': False,
                                                'typeQualifiers': {},
                                                'types': {'state': 'bool'}}],
                               'shortName': [{'argInfo': {},
                                              'args': [],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': 'Returns 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': {},
                                              'types': {}}],
                               'type': [{'argInfo': {},
                                         'args': [],
                                         'defaults': {},
                                         'deprecated': False,
                                         'doc': 'Function set type',
                                         'inArgs': [],
                                         'outArgs': [],
                                         'returnInfo': {'doc': 'the class type.',
                                                        'qualifiers': [],
                                                        'type': ('MFn',
                                                                 'Type')},
                                         'returnType': ('MFn', 'Type'),
                                         'static': False,
                                         'typeQualifiers': {},
                                         'types': {}}],
                               'usesArrayDataBuilder': [{'argInfo': {},
                                                         'args': [],
                                                         'defaults': {},
                                                         'deprecated': False,
                                                         'doc': 'Returns 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': {},
                                                         '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': 'Returns the name of this class.',
                                         'inArgs': [],
                                         'outArgs': [],
                                         'returnInfo': {'doc': 'Name of this class.',
                                                        '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': 'Determines 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': {},
                                      'types': {'mtype': ('MFn', 'Type')}},
                                     {'argInfo': {'object': {'doc': 'Maya Object to be tested for compatibility',
                                                             'type': 'MObject'}},
                                      'args': [('object', 'MObject', 'in')],
                                      'defaults': {},
                                      'deprecated': False,
                                      'doc': 'Determines 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'}}],
                          'isValid': [{'argInfo': {'mtype': {'doc': 'Maya Object type',
                                                             'type': ('MFn',
                                                                      'Type')}},
                                       'args': [('mtype',
                                                 ('MFn', 'Type'),
                                                 'in')],
                                       'defaults': {},
                                       'deprecated': False,
                                       'doc': 'Returns true if type is in the range of valid types.',
                                       'inArgs': ['mtype'],
                                       'outArgs': [],
                                       'returnInfo': {'doc': 'Type string.',
                                                      'qualifiers': [],
                                                      'type': 'bool'},
                                       'returnType': 'bool',
                                       'static': True,
                                       'typeQualifiers': {},
                                       'types': {'mtype': ('MFn', 'Type')}}],
                          'object': [{'argInfo': {},
                                      'args': [],
                                      'defaults': {},
                                      'deprecated': False,
                                      'doc': 'Returns 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': {},
                                      'types': {}}],
                          'setObject': [{'argInfo': {'object': {'doc': 'Maya Object which is the target for attachment',
                                                                'type': 'MObject'}},
                                         'args': [('object', 'MObject', 'in')],
                                         'defaults': {},
                                         'deprecated': False,
                                         'doc': 'Attaches 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'}}],
                          'type': [{'argInfo': {},
                                    'args': [],
                                    'defaults': {},
                                    'deprecated': False,
                                    'doc': 'Determines the type of the Function Set within the API RTTI system.',
                                    'inArgs': [],
                                    'outArgs': [],
                                    'returnInfo': {'doc': 'Function Set type',
                                                   'qualifiers': [],
                                                   'type': ('MFn', 'Type')},
                                    'returnType': ('MFn', 'Type'),
                                    'static': False,
                                    'typeQualifiers': {},
                                    'types': {}}],
                          'typeString': [{'argInfo': {'mtype': {'doc': 'Maya Object type',
                                                                'type': ('MFn',
                                                                         'Type')}},
                                          'args': [('mtype',
                                                    ('MFn', 'Type'),
                                                    'in')],
                                          'defaults': {},
                                          'deprecated': False,
                                          'doc': 'Returns the type string for a given type.',
                                          'inArgs': ['mtype'],
                                          'outArgs': [],
                                          'returnInfo': {'doc': 'Type string.',
                                                         'qualifiers': ['*'],
                                                         'type': 'char'},
                                          'returnType': 'char',
                                          'static': True,
                                          'typeQualifiers': {},
                                          'types': {'mtype': ('MFn',
                                                              'Type')}}]},
              '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': {},
                                                 'values': "Enum('Origin', {'kLocalOrigin': 0, 'kWorldOrigin': 1})"},
                                      'TargetType': {'valueDocs': {},
                                                     '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': 'Adds 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': "Adds 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',
                                                                                         '&'],
                                                                          'newTarget': ['const',
                                                                                        '&']},
                                                       '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': "Adds 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',
                                                                                         '&']},
                                                       'types': {'baseObject': 'MObject',
                                                                 'fullWeight': 'double',
                                                                 'targetType': ('MFnBlendShapeDeformer',
                                                                                'TargetType'),
                                                                 'weightIndex': 'int'}}],
                                        'className': [{'argInfo': {},
                                                       'args': [],
                                                       'defaults': {},
                                                       'deprecated': False,
                                                       'doc': 'Returns the name of this class.',
                                                       'inArgs': [],
                                                       'outArgs': [],
                                                       'returnInfo': {'doc': 'Name of this class.',
                                                                      'qualifiers': ['*'],
                                                                      'type': 'char'},
                                                       'returnType': 'char',
                                                       'static': True,
                                                       'typeQualifiers': {},
                                                       'types': {}}],
                                        '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': 'Creates 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': {},
                                                    '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': 'Creates 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': {'baseObjects': ['const',
                                                                                       '&']},
                                                    'types': {'baseObjects': 'MObjectArray',
                                                              'historyLoc': ('MFnBlendShapeDeformer',
                                                                             'HistoryLocation'),
                                                              'originSpace': ('MFnBlendShapeDeformer',
                                                                              'Origin')}}],
                                        'envelope': [{'argInfo': {},
                                                      'args': [],
                                                      'defaults': {},
                                                      'deprecated': False,
                                                      'doc': 'Gets the envelope value of the deformer.',
                                                      'inArgs': [],
                                                      'inverse': ('setEnvelope',
                                                                  False),
                                                      'outArgs': [],
                                                      'returnInfo': {'doc': 'Envelope value',
                                                                     'qualifiers': [],
                                                                     'type': 'float'},
                                                      'returnType': 'float',
                                                      'static': False,
                                                      'typeQualifiers': {},
                                                      'types': {}}],
                                        'getBaseObjects': [{'argInfo': {'objects': {'doc': 'storage for the array of base objects',
                                                                                    'type': 'MObjectArray'}},
                                                            'args': [('objects',
                                                                      'MObjectArray',
                                                                      'out')],
                                                            'defaults': {},
                                                            'deprecated': False,
                                                            'doc': 'Get 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': 'Get 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': {'targetObjects': ['&']},
                                                        'types': {'baseObject': 'MObject',
                                                                  'targetObjects': 'MObjectArray',
                                                                  'weightIndex': 'int'}}],
                                        'historyLocation': [{'argInfo': {},
                                                             'args': [],
                                                             'defaults': {},
                                                             'deprecated': False,
                                                             'doc': 'Gets 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': {},
                                                             'types': {}}],
                                        'numWeights': [{'argInfo': {},
                                                        'args': [],
                                                        'defaults': {},
                                                        'deprecated': False,
                                                        'doc': 'Return 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': 'uint'},
                                                        'returnType': 'uint',
                                                        'static': False,
                                                        'typeQualifiers': {},
                                                        'types': {}}],
                                        'origin': [{'argInfo': {},
                                                    'args': [],
                                                    'defaults': {},
                                                    'deprecated': False,
                                                    'doc': 'Gets 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': {},
                                                    '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': 'Remove 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',
                                                                                            '&'],
                                                                             'target': ['const',
                                                                                        '&']},
                                                          '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': 'Sets the envelope value of the deformer.',
                                                         'inArgs': ['envelope'],
                                                         'inverse': ('envelope',
                                                                     True),
                                                         'outArgs': [],
                                                         'returnInfo': {'doc': '',
                                                                        'qualifiers': [],
                                                                        'type': None},
                                                         'returnType': None,
                                                         'static': False,
                                                         'typeQualifiers': {},
                                                         'types': {'envelope': 'float'}}],
                                        'setOrigin': [{'argInfo': {'space': {'doc': 'origin space',
                                                                             'type': ('MFnBlendShapeDeformer',
                                                                                      'Origin')}},
                                                       'args': [('space',
                                                                 ('MFnBlendShapeDeformer',
                                                                  'Origin'),
                                                                 'in')],
                                                       'defaults': {},
                                                       'deprecated': False,
                                                       'doc': 'Sets 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': {},
                                                       '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': 'Set 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']},
                                                       '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': 'A 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': {'targetItemIndices': ['&'],
                                                                                    'weightIndex': ['unsigned']},
                                                                 'types': {'baseObject': 'MObject',
                                                                           'targetItemIndices': 'MIntArray',
                                                                           'weightIndex': 'uint'}}],
                                        'type': [{'argInfo': {},
                                                  'args': [],
                                                  'defaults': {},
                                                  'deprecated': False,
                                                  'doc': 'Function set type',
                                                  'inArgs': [],
                                                  'outArgs': [],
                                                  'returnInfo': {'doc': 'the class type.',
                                                                 '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': 'Get 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': {'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': 'Return 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': [('setEccentricity', 'eccentricity'),
                                     ('setSpecularRollOff', 'specularRollOff')],
                     'methods': {'className': [{'argInfo': {},
                                                'args': [],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': 'Returns the name of this class.',
                                                'inArgs': [],
                                                'outArgs': [],
                                                'returnInfo': {'doc': 'Name of this class.',
                                                               'qualifiers': ['*'],
                                                               'type': 'char'},
                                                'returnType': 'char',
                                                'static': True,
                                                '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': 'Creates 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': {},
                                             'types': {'UIvisible': 'bool'}}],
                                 'eccentricity': [{'argInfo': {},
                                                   'args': [],
                                                   'defaults': {},
                                                   'deprecated': False,
                                                   'doc': 'Retrieves 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': {},
                                                   'types': {}}],
                                 'setEccentricity': [{'argInfo': {'eccentr': {'doc': 'value to which the attribute will be set.',
                                                                              'type': 'float'}},
                                                      'args': [('eccentr',
                                                                'float',
                                                                'in')],
                                                      'defaults': {},
                                                      'deprecated': False,
                                                      'doc': 'Sets 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': 'Sets 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': 'Retrieves 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': {},
                                                      'types': {}}],
                                 'type': [{'argInfo': {},
                                           'args': [],
                                           'defaults': {},
                                           'deprecated': False,
                                           'doc': 'Function set type',
                                           'inArgs': [],
                                           'outArgs': [],
                                           'returnInfo': {'doc': 'the class type.',
                                                          '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.',
                                                    '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.',
                                                    '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': [('setAspectRatio', 'aspectRatio'),
                                ('setCameraScale', 'cameraScale'),
                                ('setCenterOfInterest', 'centerOfInterest'),
                                ('setCenterOfInterestPoint',
                                 'centerOfInterestPoint'),
                                ('setClippingPlanes', 'isClippingPlanes'),
                                ('setDepthOfField', 'isDepthOfField'),
                                ('setDisplayFilmGate', 'isDisplayFilmGate'),
                                ('setDisplayGateMask', 'isDisplayGateMask'),
                                ('setEyePoint', 'eyePoint'),
                                ('setFStop', 'fStop'),
                                ('setFarClippingPlane', 'farClippingPlane'),
                                ('setFarFocusDistance', 'farFocusDistance'),
                                ('setFilmFit', 'filmFit'),
                                ('setFilmFitOffset', 'filmFitOffset'),
                                ('setFilmRollOrder', 'filmRollOrder'),
                                ('setFilmRollValue', 'filmRollValue'),
                                ('setFilmTranslateH', 'filmTranslateH'),
                                ('setFilmTranslateV', 'filmTranslateV'),
                                ('setFocalLength', 'focalLength'),
                                ('setFocusDistance', 'focusDistance'),
                                ('setHorizontalFieldOfView',
                                 'horizontalFieldOfView'),
                                ('setHorizontalFilmAperture',
                                 'horizontalFilmAperture'),
                                ('setHorizontalFilmOffset',
                                 'horizontalFilmOffset'),
                                ('setHorizontalPan', 'horizontalPan'),
                                ('setHorizontalRollPivot',
                                 'horizontalRollPivot'),
                                ('setHorizontalShake', 'horizontalShake'),
                                ('setIsOrtho', 'isOrtho'),
                                ('setLensSqueezeRatio', 'lensSqueezeRatio'),
                                ('setMotionBlur', 'isMotionBlur'),
                                ('setNearClippingPlane', 'nearClippingPlane'),
                                ('setNearFocusDistance', 'nearFocusDistance'),
                                ('setOrthoWidth', 'orthoWidth'),
                                ('setOverscan', 'overscan'),
                                ('setPanZoomEnabled', 'panZoomEnabled'),
                                ('setPostScale', 'postScale'),
                                ('setPreScale', 'preScale'),
                                ('setRenderPanZoom', 'renderPanZoom'),
                                ('setShakeEnabled', 'shakeEnabled'),
                                ('setShakeOverscan', 'shakeOverscan'),
                                ('setShakeOverscanEnabled',
                                 'shakeOverscanEnabled'),
                                ('setShutterAngle', 'shutterAngle'),
                                ('setStereoHIT', 'stereoHIT'),
                                ('setStereoHITEnabled', 'stereoHITEnabled'),
                                ('setTumblePivot', 'tumblePivot'),
                                ('setUsePivotAsLocalSpace',
                                 'usePivotAsLocalSpace'),
                                ('setVerticalFieldOfView',
                                 'verticalFieldOfView'),
                                ('setVerticalFilmAperture',
                                 'verticalFilmAperture'),
                                ('setVerticalFilmOffset', 'verticalFilmOffset'),
                                ('setVerticalLock', 'isVerticalLock'),
                                ('setVerticalPan', 'verticalPan'),
                                ('setVerticalRollPivot', 'verticalRollPivot'),
                                ('setVerticalShake', 'verticalShake'),
                                ('setZoom', 'zoom')],
                'methods': {'aspectRatio': [{'argInfo': {},
                                             'args': [],
                                             'defaults': {},
                                             'deprecated': False,
                                             'doc': 'Returns the aspect ratio for the camera.',
                                             'inArgs': [],
                                             'inverse': ('setAspectRatio',
                                                         False),
                                             'outArgs': [],
                                             'returnInfo': {'doc': 'The aspect ratio',
                                                            'qualifiers': [],
                                                            'type': 'double'},
                                             'returnType': 'double',
                                             'static': False,
                                             'typeQualifiers': {},
                                             'types': {}}],
                            'cameraScale': [{'argInfo': {},
                                             'args': [],
                                             'defaults': {},
                                             'deprecated': False,
                                             'doc': 'Returns the camera scale.',
                                             'inArgs': [],
                                             'inverse': ('setCameraScale',
                                                         False),
                                             'outArgs': [],
                                             'returnInfo': {'doc': 'The scale value of the camera',
                                                            'qualifiers': [],
                                                            'type': 'double'},
                                             'returnType': 'double',
                                             'static': False,
                                             'typeQualifiers': {},
                                             'types': {}}],
                            'centerOfInterest': [{'argInfo': {},
                                                  'args': [],
                                                  'defaults': {},
                                                  'deprecated': False,
                                                  'doc': "Return 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': 'linear'},
                                                  'returnType': 'double',
                                                  'static': False,
                                                  'typeQualifiers': {},
                                                  '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': 'Returns 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': {},
                                                       'types': {'space': ('MSpace',
                                                                           'Space')}}],
                            'className': [{'argInfo': {},
                                           'args': [],
                                           'defaults': {},
                                           'deprecated': False,
                                           'doc': 'Returns the name of this class.',
                                           'inArgs': [],
                                           'outArgs': [],
                                           'returnInfo': {'doc': 'Name of this class.',
                                                          'qualifiers': ['*'],
                                                          'type': 'char'},
                                           'returnType': 'char',
                                           'static': True,
                                           'typeQualifiers': {},
                                           'types': {}}],
                            'computeDepthOfField': [{'argInfo': {},
                                                     'args': [],
                                                     'defaults': {},
                                                     'deprecated': False,
                                                     'doc': 'Status code',
                                                     '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': 'nearLimit',
                                                     'inArgs': ['nearLimit'],
                                                     'outArgs': [],
                                                     'returnInfo': {'doc': '',
                                                                    'qualifiers': [],
                                                                    'type': None},
                                                     'returnType': None,
                                                     'static': False,
                                                     'typeQualifiers': {},
                                                     'types': {'nearLimit': 'double'}}],
                            'copyViewFrom': [{'argInfo': {'otherCamera': {'doc': 'Camera to copy view from',
                                                                          'type': 'MDagPath'}},
                                              'args': [('otherCamera',
                                                        'MDagPath',
                                                        'in')],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': 'Copy 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': 'Creates 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': {},
                                        'types': {}},
                                       {'argInfo': {'parent': {'doc': 'The parent of the new camera',
                                                               'type': 'MObject'}},
                                        'args': [('parent', 'MObject', 'in')],
                                        'defaults': {},
                                        'deprecated': False,
                                        'doc': 'Creates 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': {'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': 'Returns 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': {},
                                          'types': {'space': ('MSpace',
                                                              'Space')}}],
                            'fStop': [{'argInfo': {},
                                       'args': [],
                                       'defaults': {},
                                       'deprecated': False,
                                       'doc': 'Returns 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': {},
                                       'types': {}}],
                            'farClippingPlane': [{'argInfo': {},
                                                  'args': [],
                                                  'defaults': {},
                                                  'deprecated': False,
                                                  'doc': 'Returns 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': 'linear'},
                                                  'returnType': 'double',
                                                  'static': False,
                                                  'typeQualifiers': {},
                                                  'types': {}}],
                            'farFocusDistance': [{'argInfo': {},
                                                  'args': [],
                                                  'defaults': {},
                                                  'deprecated': False,
                                                  'doc': 'Returns 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': 'linear'},
                                                  'returnType': 'double',
                                                  'static': False,
                                                  'typeQualifiers': {},
                                                  'types': {}}],
                            'filmFit': [{'argInfo': {},
                                         'args': [],
                                         'defaults': {},
                                         'deprecated': False,
                                         'doc': 'Returns 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': {},
                                         'types': {}}],
                            'filmFitOffset': [{'argInfo': {},
                                               'args': [],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': 'Returns 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': {},
                                               'types': {}}],
                            'filmRollOrder': [{'argInfo': {},
                                               'args': [],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': 'Returns the current roll order',
                                               'inArgs': [],
                                               'inverse': ('setFilmRollOrder',
                                                           False),
                                               'outArgs': [],
                                               'returnInfo': {'doc': 'The roll order',
                                                              'qualifiers': [],
                                                              'type': ('MFnCamera',
                                                                       'RollOrder')},
                                               'returnType': ('MFnCamera',
                                                              'RollOrder'),
                                               'static': False,
                                               'typeQualifiers': {},
                                               'types': {}}],
                            'filmRollValue': [{'argInfo': {},
                                               'args': [],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': 'Returns 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': {},
                                               'types': {}}],
                            'filmTranslateH': [{'argInfo': {},
                                                'args': [],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': 'Returns 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': {},
                                                'types': {}}],
                            'filmTranslateV': [{'argInfo': {},
                                                'args': [],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': 'Returns 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': {},
                                                'types': {}}],
                            'focalLength': [{'argInfo': {},
                                             'args': [],
                                             'defaults': {},
                                             'deprecated': False,
                                             'doc': 'Returns 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': {},
                                             'types': {}}],
                            'focusDistance': [{'argInfo': {},
                                               'args': [],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': 'Returns 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': 'linear'},
                                               'returnType': 'double',
                                               'static': False,
                                               'typeQualifiers': {},
                                               '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': 'Returns 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': 'Returns 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': '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': 'Returns 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': {'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': 'linear'}},
                                                'args': [('distance',
                                                          'double',
                                                          'in'),
                                                         ('clipPlane',
                                                          'MPoint__array4',
                                                          'out'),
                                                         ('applyPanZoom',
                                                          'bool',
                                                          'in')],
                                                'defaults': {'applyPanZoom': False},
                                                'deprecated': False,
                                                'doc': 'Returns the film frustum for the camera. The frustum defines the projective transformation.',
                                                'inArgs': ['distance',
                                                           'applyPanZoom'],
                                                'outArgs': ['clipPlane'],
                                                'returnInfo': {'doc': '',
                                                               'qualifiers': [],
                                                               'type': None},
                                                'returnType': None,
                                                'static': False,
                                                'typeQualifiers': {},
                                                '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': 'Returns 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': 'angular'},
                                                                'verticalFOV': {'doc': 'storage for the vertical field of view',
                                                                                'type': 'double',
                                                                                'unitType': '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': 'Compute 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': {'horizontalFOV': ['&'],
                                                                       'verticalFOV': ['&']},
                                                    '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': 'Computes 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': ['&']},
                                                     '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': 'Computes 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': ['&'],
                                                                      'offsetX': ['&'],
                                                                      'offsetY': ['&']},
                                                   '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': 'Computes 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': {'bottom': ['&'],
                                                                      'left': ['&'],
                                                                      'right': ['&'],
                                                                      'top': ['&']},
                                                   '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': 'Returns 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': {'otherCamera': ['const',
                                                                                       '&']},
                                                    'types': {'otherCamera': 'MDagPath'}}],
                            'horizontalFieldOfView': [{'argInfo': {},
                                                       'args': [],
                                                       'defaults': {},
                                                       'deprecated': False,
                                                       'doc': 'Returns 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': 'angular'},
                                                       'returnType': 'double',
                                                       'static': False,
                                                       'typeQualifiers': {},
                                                       'types': {}}],
                            'horizontalFilmAperture': [{'argInfo': {},
                                                        'args': [],
                                                        'defaults': {},
                                                        'deprecated': False,
                                                        'doc': 'Returns 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': {},
                                                        'types': {}}],
                            'horizontalFilmOffset': [{'argInfo': {},
                                                      'args': [],
                                                      'defaults': {},
                                                      'deprecated': False,
                                                      'doc': 'Returns 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': {},
                                                      'types': {}}],
                            'horizontalPan': [{'argInfo': {},
                                               'args': [],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': 'Return 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': {},
                                               'types': {}}],
                            'horizontalRollPivot': [{'argInfo': {},
                                                     'args': [],
                                                     'defaults': {},
                                                     'deprecated': False,
                                                     'doc': 'Returns the current horizontal roll pivot value.',
                                                     'inArgs': [],
                                                     'inverse': ('setHorizontalRollPivot',
                                                                 False),
                                                     'outArgs': [],
                                                     'returnInfo': {'doc': 'The horizontal roll pivot value.',
                                                                    'qualifiers': [],
                                                                    'type': 'double',
                                                                    'unitType': 'linear'},
                                                     'returnType': 'double',
                                                     'static': False,
                                                     'typeQualifiers': {},
                                                     'types': {}}],
                            'horizontalShake': [{'argInfo': {},
                                                 'args': [],
                                                 'defaults': {},
                                                 'deprecated': False,
                                                 'doc': 'Returns 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': {},
                                                 'types': {}}],
                            'isClippingPlanes': [{'argInfo': {},
                                                  'args': [],
                                                  'defaults': {},
                                                  'deprecated': False,
                                                  'doc': 'Determines 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': {},
                                                  'types': {}}],
                            'isDepthOfField': [{'argInfo': {},
                                                'args': [],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': 'Determines 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': {},
                                                'types': {}}],
                            'isDisplayFilmGate': [{'argInfo': {},
                                                   'args': [],
                                                   'defaults': {},
                                                   'deprecated': False,
                                                   'doc': 'Determines 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': {},
                                                   'types': {}}],
                            'isDisplayGateMask': [{'argInfo': {},
                                                   'args': [],
                                                   'defaults': {},
                                                   'deprecated': False,
                                                   'doc': 'Determines 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': {},
                                                   'types': {}}],
                            'isMotionBlur': [{'argInfo': {},
                                              'args': [],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': 'Determine 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': {},
                                              'types': {}}],
                            'isOrtho': [{'argInfo': {},
                                         'args': [],
                                         'defaults': {},
                                         'deprecated': False,
                                         'doc': 'Determines 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': {},
                                         'types': {}}],
                            'isVerticalLock': [{'argInfo': {},
                                                'args': [],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': 'Determines 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': {},
                                                'types': {}}],
                            'lensSqueezeRatio': [{'argInfo': {},
                                                  'args': [],
                                                  'defaults': {},
                                                  'deprecated': False,
                                                  'doc': 'Returns 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': {},
                                                  'types': {}}],
                            'nearClippingPlane': [{'argInfo': {},
                                                   'args': [],
                                                   'defaults': {},
                                                   'deprecated': False,
                                                   'doc': 'Returns 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': 'linear'},
                                                   'returnType': 'double',
                                                   'static': False,
                                                   'typeQualifiers': {},
                                                   'types': {}}],
                            'nearFocusDistance': [{'argInfo': {},
                                                   'args': [],
                                                   'defaults': {},
                                                   'deprecated': False,
                                                   'doc': 'Returns 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': 'linear'},
                                                   'returnType': 'double',
                                                   'static': False,
                                                   'typeQualifiers': {},
                                                   'types': {}}],
                            'orthoWidth': [{'argInfo': {},
                                            'args': [],
                                            'defaults': {},
                                            'deprecated': False,
                                            'doc': 'Returns the orthographic projection width.',
                                            'inArgs': [],
                                            'inverse': ('setOrthoWidth', False),
                                            'outArgs': [],
                                            'returnInfo': {'doc': 'The orthographic width',
                                                           'qualifiers': [],
                                                           'type': 'double'},
                                            'returnType': 'double',
                                            'static': False,
                                            'typeQualifiers': {},
                                            'types': {}}],
                            'overscan': [{'argInfo': {},
                                          'args': [],
                                          'defaults': {},
                                          'deprecated': False,
                                          'doc': 'Returns 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': {},
                                          'types': {}}],
                            'panZoomEnabled': [{'argInfo': {},
                                                'args': [],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': 'Return 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': {},
                                                'types': {}}],
                            'postProjectionMatrix': [{'argInfo': {},
                                                      'args': [],
                                                      'defaults': {},
                                                      'deprecated': False,
                                                      'doc': 'Returns 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': {},
                                                      'types': {}},
                                                     {'argInfo': {'context': {'doc': 'DG time-context to specify time of evaluation',
                                                                              'type': 'MDGContext'}},
                                                      'args': [('context',
                                                                'MDGContext',
                                                                'in')],
                                                      'defaults': {},
                                                      'deprecated': False,
                                                      'doc': 'Returns 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': {'context': ['const',
                                                                                     '&']},
                                                      'types': {'context': 'MDGContext'}}],
                            'postScale': [{'argInfo': {},
                                           'args': [],
                                           'defaults': {},
                                           'deprecated': False,
                                           'doc': "Return 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': {},
                                           'types': {}}],
                            'preScale': [{'argInfo': {},
                                          'args': [],
                                          'defaults': {},
                                          'deprecated': False,
                                          'doc': "Return 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': {},
                                          'types': {}}],
                            'projectionMatrix': [{'argInfo': {},
                                                  'args': [],
                                                  'defaults': {},
                                                  'deprecated': False,
                                                  'doc': "Returns 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': {},
                                                  'types': {}},
                                                 {'argInfo': {'context': {'doc': 'DG time-context to specify time of evaluation.',
                                                                          'type': 'MDGContext'}},
                                                  'args': [('context',
                                                            'MDGContext',
                                                            'in')],
                                                  'defaults': {},
                                                  'deprecated': False,
                                                  'doc': 'Returns 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': {'context': ['const',
                                                                                 '&']},
                                                  'types': {'context': 'MDGContext'}}],
                            'renderPanZoom': [{'argInfo': {},
                                               'args': [],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': 'Return 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': {},
                                               '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': 'Returns 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': {},
                                                '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': 'Convenience 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': {'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': "Set 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': {},
                                                'types': {'aspectRatio': 'double'}}],
                            'setCameraScale': [{'argInfo': {'scale': {'doc': 'The camera scale value to be set',
                                                                      'type': 'double'}},
                                                'args': [('scale',
                                                          'double',
                                                          'in')],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': 'Sets the camera scale.',
                                                'inArgs': ['scale'],
                                                'inverse': ('cameraScale',
                                                            True),
                                                'outArgs': [],
                                                'returnInfo': {'doc': '',
                                                               'qualifiers': [],
                                                               'type': None},
                                                'returnType': None,
                                                'static': False,
                                                'typeQualifiers': {},
                                                'types': {'scale': 'double'}}],
                            'setCenterOfInterest': [{'argInfo': {'dist': {'doc': 'center of interest distance value',
                                                                          'type': 'double',
                                                                          'unitType': 'linear'}},
                                                     'args': [('dist',
                                                               'double',
                                                               'in')],
                                                     'defaults': {},
                                                     'deprecated': False,
                                                     'doc': 'Set 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': {},
                                                     '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': "Positions 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',
                                                                                                  '&']},
                                                          'types': {'centerOfInterest': 'MPoint',
                                                                    'space': ('MSpace',
                                                                              'Space')}}],
                            'setClippingPlanes': [{'argInfo': {'ClippingPlanes': {'doc': '',
                                                                                  'type': 'bool'}},
                                                   'args': [('ClippingPlanes',
                                                             'bool',
                                                             'in')],
                                                   'defaults': {},
                                                   'deprecated': False,
                                                   'doc': 'Turn on/off manual setting of clip planes.',
                                                   'inArgs': ['ClippingPlanes'],
                                                   'inverse': ('isClippingPlanes',
                                                               True),
                                                   'outArgs': [],
                                                   'returnInfo': {'doc': '',
                                                                  'qualifiers': [],
                                                                  'type': None},
                                                   'returnType': None,
                                                   'static': False,
                                                   'typeQualifiers': {},
                                                   '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': 'Specifies 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': {},
                                                 'types': {'depthOfField': 'bool'}}],
                            'setDisplayFilmGate': [{'argInfo': {'displayFilmGate': {'doc': 'Specifies whether to display the film gate.',
                                                                                    'type': 'bool'}},
                                                    'args': [('displayFilmGate',
                                                              'bool',
                                                              'in')],
                                                    'defaults': {},
                                                    'deprecated': False,
                                                    'doc': 'Activate 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': {},
                                                    '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': 'Activate 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': {},
                                                    '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': "Positions 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',
                                                                                '&']},
                                             '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': 'Sets the f-stop value for the camera.',
                                          'inArgs': ['fStop'],
                                          'inverse': ('fStop', True),
                                          'outArgs': [],
                                          'returnInfo': {'doc': '',
                                                         'qualifiers': [],
                                                         'type': None},
                                          'returnType': None,
                                          'static': False,
                                          'typeQualifiers': {},
                                          'types': {'fStop': 'double'}}],
                            'setFarClippingPlane': [{'argInfo': {'dFar': {'doc': 'The far clipping plane value to be set',
                                                                          'type': 'double',
                                                                          'unitType': 'linear'}},
                                                     'args': [('dFar',
                                                               'double',
                                                               'in')],
                                                     'defaults': {},
                                                     'deprecated': False,
                                                     'doc': 'Set the distances to the Far Clipping Plane.',
                                                     'inArgs': ['dFar'],
                                                     'inverse': ('farClippingPlane',
                                                                 True),
                                                     'outArgs': [],
                                                     'returnInfo': {'doc': '',
                                                                    'qualifiers': [],
                                                                    'type': None},
                                                     'returnType': None,
                                                     'static': False,
                                                     'typeQualifiers': {},
                                                     'types': {'dFar': 'double'}}],
                            'setFarFocusDistance': [{'argInfo': {'farFocusDistance': {'doc': 'The far focus distance value to be set',
                                                                                      'type': 'double',
                                                                                      'unitType': 'linear'}},
                                                     'args': [('farFocusDistance',
                                                               'double',
                                                               'in')],
                                                     'defaults': {},
                                                     'deprecated': False,
                                                     'doc': 'Set the farthest distance within the well-focus region',
                                                     'inArgs': ['farFocusDistance'],
                                                     'inverse': ('farFocusDistance',
                                                                 True),
                                                     'outArgs': [],
                                                     'returnInfo': {'doc': '',
                                                                    'qualifiers': [],
                                                                    'type': None},
                                                     'returnType': None,
                                                     'static': False,
                                                     'typeQualifiers': {},
                                                     'types': {'farFocusDistance': 'double'}}],
                            'setFilmFit': [{'argInfo': {'filmFit': {'doc': 'The type of film fit',
                                                                    'type': ('MFnCamera',
                                                                             'FilmFit')}},
                                            'args': [('filmFit',
                                                      ('MFnCamera', 'FilmFit'),
                                                      'in')],
                                            'defaults': {},
                                            'deprecated': False,
                                            'doc': 'Sets 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': {},
                                            'types': {'filmFit': ('MFnCamera',
                                                                  'FilmFit')}}],
                            'setFilmFitOffset': [{'argInfo': {'filmFitOffset': {'doc': '',
                                                                                'type': 'double'}},
                                                  'args': [('filmFitOffset',
                                                            'double',
                                                            'in')],
                                                  'defaults': {},
                                                  'deprecated': False,
                                                  'doc': 'Set the film fit offset for the camera.',
                                                  'inArgs': ['filmFitOffset'],
                                                  'inverse': ('filmFitOffset',
                                                              True),
                                                  'outArgs': [],
                                                  'returnInfo': {'doc': '',
                                                                 'qualifiers': [],
                                                                 'type': None},
                                                  'returnType': None,
                                                  'static': False,
                                                  'typeQualifiers': {},
                                                  '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': 'Assign 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': {},
                                                  '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': 'Set the film roll value for film back.',
                                                  'inArgs': ['filmRollValue'],
                                                  'inverse': ('filmRollValue',
                                                              True),
                                                  'outArgs': [],
                                                  'returnInfo': {'doc': '',
                                                                 'qualifiers': [],
                                                                 'type': None},
                                                  'returnType': None,
                                                  'static': False,
                                                  'typeQualifiers': {},
                                                  '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': 'Set the horizontal film translate.',
                                                   'inArgs': ['translate'],
                                                   'inverse': ('filmTranslateH',
                                                               True),
                                                   'outArgs': [],
                                                   'returnInfo': {'doc': '',
                                                                  'qualifiers': [],
                                                                  'type': None},
                                                   'returnType': None,
                                                   'static': False,
                                                   'typeQualifiers': {},
                                                   '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': 'Set the vertical film translate.',
                                                   'inArgs': ['translate'],
                                                   'inverse': ('filmTranslateV',
                                                               True),
                                                   'outArgs': [],
                                                   'returnInfo': {'doc': '',
                                                                  'qualifiers': [],
                                                                  'type': None},
                                                   'returnType': None,
                                                   'static': False,
                                                   'typeQualifiers': {},
                                                   'types': {'translate': 'double'}}],
                            'setFocalLength': [{'argInfo': {'focalLength': {'doc': 'The focal length value to be set',
                                                                            'type': 'double'}},
                                                'args': [('focalLength',
                                                          'double',
                                                          'in')],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': 'Sets the focal length for the camera.',
                                                'inArgs': ['focalLength'],
                                                'inverse': ('focalLength',
                                                            True),
                                                'outArgs': [],
                                                'returnInfo': {'doc': '',
                                                               'qualifiers': [],
                                                               'type': None},
                                                'returnType': None,
                                                'static': False,
                                                'typeQualifiers': {},
                                                'types': {'focalLength': 'double'}}],
                            'setFocusDistance': [{'argInfo': {'distance': {'doc': 'The focus distance to be set',
                                                                           'type': 'double',
                                                                           'unitType': 'linear'}},
                                                  'args': [('distance',
                                                            'double',
                                                            'in')],
                                                  'defaults': {},
                                                  'deprecated': False,
                                                  'doc': 'Set 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': {},
                                                  'types': {'distance': 'double'}}],
                            'setHorizontalFieldOfView': [{'argInfo': {'fov': {'doc': 'The horizontal field of view value to be set',
                                                                              'type': 'double',
                                                                              'unitType': 'angular'}},
                                                          'args': [('fov',
                                                                    'double',
                                                                    'in')],
                                                          'defaults': {},
                                                          'deprecated': False,
                                                          'doc': 'Sets the horizontal field of view for the camera.',
                                                          'inArgs': ['fov'],
                                                          'inverse': ('horizontalFieldOfView',
                                                                      True),
                                                          'outArgs': [],
                                                          'returnInfo': {'doc': '',
                                                                         'qualifiers': [],
                                                                         'type': None},
                                                          'returnType': None,
                                                          'static': False,
                                                          'typeQualifiers': {},
                                                          'types': {'fov': 'double'}}],
                            'setHorizontalFilmAperture': [{'argInfo': {'hFilmAperture': {'doc': 'Horizontal file aperture value to be set',
                                                                                         'type': 'double'}},
                                                           'args': [('hFilmAperture',
                                                                     'double',
                                                                     'in')],
                                                           'defaults': {},
                                                           'deprecated': False,
                                                           'doc': 'Change 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': {},
                                                           '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': 'Change 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': {},
                                                         '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': 'Changes 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': {},
                                                  'types': {'hPan': 'double'}}],
                            'setHorizontalRollPivot': [{'argInfo': {'horizontalRollPivot': {'doc': 'Specifies the horizontal pivot value.',
                                                                                            'type': 'double',
                                                                                            'unitType': 'linear'}},
                                                        'args': [('horizontalRollPivot',
                                                                  'double',
                                                                  'in')],
                                                        'defaults': {},
                                                        'deprecated': False,
                                                        'doc': 'Set the horizontal roll pivot for film back roll.',
                                                        'inArgs': ['horizontalRollPivot'],
                                                        'inverse': ('horizontalRollPivot',
                                                                    True),
                                                        'outArgs': [],
                                                        'returnInfo': {'doc': '',
                                                                       'qualifiers': [],
                                                                       'type': None},
                                                        'returnType': None,
                                                        'static': False,
                                                        'typeQualifiers': {},
                                                        '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': 'Change 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': {},
                                                    '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': 'Switch 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': {},
                                            'types': {'orthoState': 'bool'}},
                                           {'argInfo': {'orthoState': {'doc': 'If true then the camera will be orthographic',
                                                                       'type': 'bool'},
                                                        'useDist': {'doc': '',
                                                                    'type': 'double',
                                                                    'unitType': 'linear'}},
                                            'args': [('orthoState',
                                                      'bool',
                                                      'in'),
                                                     ('useDist',
                                                      'double',
                                                      'in')],
                                            'defaults': {},
                                            'deprecated': False,
                                            'doc': 'Switch 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': [],
                                            'returnInfo': {'doc': '',
                                                           'qualifiers': [],
                                                           'type': None},
                                            'returnType': None,
                                            'static': False,
                                            'typeQualifiers': {},
                                            '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': 'Set 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': {},
                                                     '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': 'Turns motion blur on/off for the camera.',
                                               'inArgs': ['motionBlur'],
                                               'inverse': ('isMotionBlur',
                                                           True),
                                               'outArgs': [],
                                               'returnInfo': {'doc': '',
                                                              'qualifiers': [],
                                                              'type': None},
                                               'returnType': None,
                                               'static': False,
                                               'typeQualifiers': {},
                                               'types': {'motionBlur': 'bool'}}],
                            'setNearClippingPlane': [{'argInfo': {'dNear': {'doc': 'The near clipping plane value to be set',
                                                                            'type': 'double',
                                                                            'unitType': 'linear'}},
                                                      'args': [('dNear',
                                                                'double',
                                                                'in')],
                                                      'defaults': {},
                                                      'deprecated': False,
                                                      'doc': 'Set the distances to the Near Clipping Plane.',
                                                      'inArgs': ['dNear'],
                                                      'inverse': ('nearClippingPlane',
                                                                  True),
                                                      'outArgs': [],
                                                      'returnInfo': {'doc': '',
                                                                     'qualifiers': [],
                                                                     'type': None},
                                                      'returnType': None,
                                                      'static': False,
                                                      'typeQualifiers': {},
                                                      'types': {'dNear': 'double'}}],
                            'setNearFarClippingPlanes': [{'argInfo': {'dFar': {'doc': 'The far clipping plane value to be set',
                                                                               'type': 'double',
                                                                               'unitType': 'linear'},
                                                                      'dNear': {'doc': 'The near clipping plane value to be set',
                                                                                'type': 'double',
                                                                                'unitType': 'linear'}},
                                                          'args': [('dNear',
                                                                    'double',
                                                                    'in'),
                                                                   ('dFar',
                                                                    'double',
                                                                    'in')],
                                                          'defaults': {},
                                                          'deprecated': False,
                                                          'doc': 'Set the distances to the Near and Far Clipping Planes.',
                                                          'inArgs': ['dNear',
                                                                     'dFar'],
                                                          'outArgs': [],
                                                          'returnInfo': {'doc': '',
                                                                         'qualifiers': [],
                                                                         'type': None},
                                                          'returnType': None,
                                                          'static': False,
                                                          'typeQualifiers': {},
                                                          'types': {'dFar': 'double',
                                                                    'dNear': 'double'}}],
                            'setNearFocusDistance': [{'argInfo': {'nearFocusDistance': {'doc': 'The near focus distance value to be set',
                                                                                        'type': 'double',
                                                                                        'unitType': 'linear'}},
                                                      'args': [('nearFocusDistance',
                                                                'double',
                                                                'in')],
                                                      'defaults': {},
                                                      'deprecated': False,
                                                      'doc': 'Set the nearest distance within the well-focus region',
                                                      'inArgs': ['nearFocusDistance'],
                                                      'inverse': ('nearFocusDistance',
                                                                  True),
                                                      'outArgs': [],
                                                      'returnInfo': {'doc': '',
                                                                     'qualifiers': [],
                                                                     'type': None},
                                                      'returnType': None,
                                                      'static': False,
                                                      'typeQualifiers': {},
                                                      'types': {'nearFocusDistance': 'double'}}],
                            'setOrthoWidth': [{'argInfo': {'orthoWidth': {'doc': 'The ortho width value to be set',
                                                                          'type': 'double'}},
                                               'args': [('orthoWidth',
                                                         'double',
                                                         'in')],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': 'Sets 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': {},
                                               'types': {'orthoWidth': 'double'}}],
                            'setOverscan': [{'argInfo': {'overscan': {'doc': '',
                                                                      'type': 'double'}},
                                             'args': [('overscan',
                                                       'double',
                                                       'in')],
                                             'defaults': {},
                                             'deprecated': False,
                                             'doc': 'Set the percent of overscan for this camera.',
                                             'inArgs': ['overscan'],
                                             'inverse': ('overscan', True),
                                             'outArgs': [],
                                             'returnInfo': {'doc': '',
                                                            'qualifiers': [],
                                                            'type': None},
                                             'returnType': None,
                                             'static': False,
                                             'typeQualifiers': {},
                                             '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': 'Changes 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': {},
                                                   'types': {'enabled': 'bool'}}],
                            'setPostScale': [{'argInfo': {'sf': {'doc': 'The scaling factor.',
                                                                 'type': 'double'}},
                                              'args': [('sf', 'double', 'in')],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': 'Set the post scale value.',
                                              'inArgs': ['sf'],
                                              'inverse': ('postScale', True),
                                              'outArgs': [],
                                              'returnInfo': {'doc': '',
                                                             'qualifiers': [],
                                                             'type': None},
                                              'returnType': None,
                                              'static': False,
                                              'typeQualifiers': {},
                                              'types': {'sf': 'double'}}],
                            'setPreScale': [{'argInfo': {'sf': {'doc': 'The scaling factor.',
                                                                'type': 'double'}},
                                             'args': [('sf', 'double', 'in')],
                                             'defaults': {},
                                             'deprecated': False,
                                             'doc': 'Set the pre scale value.',
                                             'inArgs': ['sf'],
                                             'inverse': ('preScale', True),
                                             'outArgs': [],
                                             'returnInfo': {'doc': '',
                                                            'qualifiers': [],
                                                            'type': None},
                                             'returnType': None,
                                             'static': False,
                                             'typeQualifiers': {},
                                             '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': 'Changes 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': {},
                                                  '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': 'Changes 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': {},
                                                 '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': 'Changes 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': {},
                                                  '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': 'Changes 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': {},
                                                         'types': {'enabled': 'bool'}}],
                            'setShutterAngle': [{'argInfo': {'shutterAngle': {'doc': 'The shutter angle value to be set',
                                                                              'type': 'double',
                                                                              'unitType': 'angular'}},
                                                 'args': [('shutterAngle',
                                                           'double',
                                                           'in')],
                                                 'defaults': {},
                                                 'deprecated': False,
                                                 'doc': 'Change 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': {},
                                                 'types': {'shutterAngle': 'double'}}],
                            'setStereoHIT': [{'argInfo': {'hit': {'doc': 'The stereo HIT value to be set',
                                                                  'type': 'double'}},
                                              'args': [('hit', 'double', 'in')],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': 'Changes 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': {},
                                              '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': 'Changes 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': {},
                                                     'types': {'enabled': 'bool'}}],
                            'setTumblePivot': [{'argInfo': {'point': {'doc': 'The tumble pivot location to be set',
                                                                      'type': 'MPoint'}},
                                                'args': [('point',
                                                          'MPoint',
                                                          'in')],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': 'The 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': 'Local 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': 'angular'}},
                                                        'args': [('fov',
                                                                  'double',
                                                                  'in')],
                                                        'defaults': {},
                                                        'deprecated': False,
                                                        'doc': 'Sets the vertical field of view for the camera.',
                                                        'inArgs': ['fov'],
                                                        'inverse': ('verticalFieldOfView',
                                                                    True),
                                                        'outArgs': [],
                                                        'returnInfo': {'doc': '',
                                                                       'qualifiers': [],
                                                                       'type': None},
                                                        'returnType': None,
                                                        'static': False,
                                                        'typeQualifiers': {},
                                                        'types': {'fov': 'double'}}],
                            'setVerticalFilmAperture': [{'argInfo': {'vFilmAperture': {'doc': 'The vertical film aperture for the camera',
                                                                                       'type': 'double'}},
                                                         'args': [('vFilmAperture',
                                                                   'double',
                                                                   'in')],
                                                         'defaults': {},
                                                         'deprecated': False,
                                                         'doc': 'Change 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': {},
                                                         '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': 'Change 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': {},
                                                       'types': {'vOffset': 'double'}}],
                            'setVerticalLock': [{'argInfo': {'lockFlag': {'doc': 'Vertical lock value to be set',
                                                                          'type': 'bool'}},
                                                 'args': [('lockFlag',
                                                           'bool',
                                                           'in')],
                                                 'defaults': {},
                                                 'deprecated': False,
                                                 'doc': 'Sets 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': {},
                                                 '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': 'Changes 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': {},
                                                'types': {'vPan': 'double'}}],
                            'setVerticalRollPivot': [{'argInfo': {'verticalRollPivot': {'doc': 'Specifies the vertical pivot value.',
                                                                                        'type': 'double',
                                                                                        'unitType': 'linear'}},
                                                      'args': [('verticalRollPivot',
                                                                'double',
                                                                'in')],
                                                      'defaults': {},
                                                      'deprecated': False,
                                                      'doc': 'Set the vertical roll pivot for film back roll.',
                                                      'inArgs': ['verticalRollPivot'],
                                                      'inverse': ('verticalRollPivot',
                                                                  True),
                                                      'outArgs': [],
                                                      'returnInfo': {'doc': '',
                                                                     'qualifiers': [],
                                                                     'type': None},
                                                      'returnType': None,
                                                      'static': False,
                                                      'typeQualifiers': {},
                                                      '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': 'Changes 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': {},
                                                  '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': 'Changes the camera 2D zoom value.',
                                         'inArgs': ['zoom'],
                                         'inverse': ('zoom', True),
                                         'outArgs': [],
                                         'returnInfo': {'doc': '',
                                                        'qualifiers': [],
                                                        'type': None},
                                         'returnType': None,
                                         'static': False,
                                         'typeQualifiers': {},
                                         'types': {'zoom': 'double'}}],
                            'shakeEnabled': [{'argInfo': {},
                                              'args': [],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': 'Returns 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': {},
                                              'types': {}}],
                            'shakeOverscan': [{'argInfo': {},
                                               'args': [],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': 'Returns 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': {},
                                               'types': {}}],
                            'shakeOverscanEnabled': [{'argInfo': {},
                                                      'args': [],
                                                      'defaults': {},
                                                      'deprecated': False,
                                                      'doc': 'Returns 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': {},
                                                      'types': {}}],
                            'shutterAngle': [{'argInfo': {},
                                              'args': [],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': 'Return 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': 'angular'},
                                              'returnType': 'double',
                                              'static': False,
                                              'typeQualifiers': {},
                                              'types': {}}],
                            'stereoHIT': [{'argInfo': {},
                                           'args': [],
                                           'defaults': {},
                                           'deprecated': False,
                                           'doc': 'Returns 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': {},
                                           'types': {}}],
                            'stereoHITEnabled': [{'argInfo': {},
                                                  'args': [],
                                                  'defaults': {},
                                                  'deprecated': False,
                                                  'doc': 'Returns 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': {},
                                                  'types': {}}],
                            'tumblePivot': [{'argInfo': {},
                                             'args': [],
                                             'defaults': {},
                                             'deprecated': False,
                                             'doc': 'Returns 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': {},
                                             'types': {}}],
                            'type': [{'argInfo': {},
                                      'args': [],
                                      'defaults': {},
                                      'deprecated': False,
                                      'doc': 'Function set type',
                                      'inArgs': [],
                                      'outArgs': [],
                                      'returnInfo': {'doc': 'the class type.',
                                                     'qualifiers': [],
                                                     'type': ('MFn', 'Type')},
                                      'returnType': ('MFn', 'Type'),
                                      'static': False,
                                      'typeQualifiers': {},
                                      'types': {}}],
                            'unnormalizedFarClippingPlane': [{'argInfo': {},
                                                              'args': [],
                                                              'defaults': {},
                                                              'deprecated': False,
                                                              'doc': 'Returns 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': {},
                                                              'types': {}}],
                            'unnormalizedNearClippingPlane': [{'argInfo': {},
                                                               'args': [],
                                                               'defaults': {},
                                                               'deprecated': False,
                                                               'doc': 'Returns 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': {},
                                                               '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': 'Returns 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': {},
                                             'types': {'space': ('MSpace',
                                                                 'Space')}}],
                            'usePivotAsLocalSpace': [{'argInfo': {},
                                                      'args': [],
                                                      'defaults': {},
                                                      'deprecated': False,
                                                      'doc': 'Returns 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': {},
                                                      'types': {}}],
                            'verticalFieldOfView': [{'argInfo': {},
                                                     'args': [],
                                                     'defaults': {},
                                                     'deprecated': False,
                                                     'doc': 'Returns 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': 'angular'},
                                                     'returnType': 'double',
                                                     'static': False,
                                                     'typeQualifiers': {},
                                                     'types': {}}],
                            'verticalFilmAperture': [{'argInfo': {},
                                                      'args': [],
                                                      'defaults': {},
                                                      'deprecated': False,
                                                      'doc': 'Returns 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': {},
                                                      'types': {}}],
                            'verticalFilmOffset': [{'argInfo': {},
                                                    'args': [],
                                                    'defaults': {},
                                                    'deprecated': False,
                                                    'doc': 'Change 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': {},
                                                    'types': {}}],
                            'verticalPan': [{'argInfo': {},
                                             'args': [],
                                             'defaults': {},
                                             'deprecated': False,
                                             'doc': 'Return 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': {},
                                             'types': {}}],
                            'verticalRollPivot': [{'argInfo': {},
                                                   'args': [],
                                                   'defaults': {},
                                                   'deprecated': False,
                                                   'doc': "Returns the vertical roll pivot's value.",
                                                   'inArgs': [],
                                                   'inverse': ('setVerticalRollPivot',
                                                               False),
                                                   'outArgs': [],
                                                   'returnInfo': {'doc': 'Vertical roll pivot',
                                                                  'qualifiers': [],
                                                                  'type': 'double',
                                                                  'unitType': 'linear'},
                                                   'returnType': 'double',
                                                   'static': False,
                                                   'typeQualifiers': {},
                                                   'types': {}}],
                            'verticalShake': [{'argInfo': {},
                                               'args': [],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': 'Change 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': {},
                                               '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': 'Returns 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': {},
                                               'types': {'space': ('MSpace',
                                                                   'Space')}}],
                            'zoom': [{'argInfo': {},
                                      'args': [],
                                      'defaults': {},
                                      'deprecated': False,
                                      'doc': 'Return 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': {},
                                      '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': [('setLayerActive', 'isLayerActive'),
                                   ('setLayerCamera', 'getLayerCamera'),
                                   ('setLayerClearDepthValue',
                                    'getLayerClearDepthValue'),
                                   ('setLayerOrder', 'getLayerOrder'),
                                   ('setLayerSceneData', 'getLayerSceneData')],
                   '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': 'Appends 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': 'Appends 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': 'Returns the name of this class.',
                                              'inArgs': [],
                                              'outArgs': [],
                                              'returnInfo': {'doc': 'Name of this class.',
                                                             'qualifiers': ['*'],
                                                             'type': 'char'},
                                              'returnType': 'char',
                                              'static': True,
                                              'typeQualifiers': {},
                                              'types': {}}],
                               'clear': [{'argInfo': {},
                                          'args': [],
                                          'defaults': {},
                                          'deprecated': False,
                                          'doc': 'Clear 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': 'Creates 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': {},
                                           'types': {}},
                                          {'argInfo': {'camList': {'doc': 'The list of cameras or stereo rigs',
                                                                   'type': 'MDagPathArray'}},
                                           'args': [('camList',
                                                     'MDagPathArray',
                                                     'in')],
                                           'defaults': {},
                                           'deprecated': False,
                                           'doc': 'Creates 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',
                                                                          '&']},
                                           'types': {'camList': 'MDagPathArray'}},
                                          {'argInfo': {'name': {'doc': 'The name for the new cameraSet node',
                                                                'type': 'MString'}},
                                           'args': [('name', 'MString', 'in')],
                                           'defaults': {},
                                           'deprecated': False,
                                           'doc': 'Creates 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',
                                                                       '&']},
                                           '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': 'Creates 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',
                                                                          '&'],
                                                              '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': 'Creates 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',
                                                                       '&'],
                                                              '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': 'Deletes 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': 'Get 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': 'This 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': 'Get 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': 'Get 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': 'Return the number of layers in the cameraSet.',
                                                 'inArgs': [],
                                                 'outArgs': [],
                                                 'returnInfo': {'doc': 'The number of layers',
                                                                'qualifiers': [],
                                                                'type': 'uint'},
                                                 'returnType': 'uint',
                                                 'static': False,
                                                 'typeQualifiers': {},
                                                 'types': {}}],
                               'getSortedIndices': [{'argInfo': {'sortedIndices': {'doc': 'The sorted indices',
                                                                                   'type': 'MUintArray'}},
                                                     'args': [('sortedIndices',
                                                               'MUintArray',
                                                               'out')],
                                                     'defaults': {},
                                                     'deprecated': False,
                                                     'doc': 'Get 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': 'Inserts 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': 'Inserts 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': 'Get 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']},
                                                  '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': 'Set 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']},
                                                   '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': 'Set 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': 'This 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': {'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': 'Set 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']},
                                                  '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': 'Set 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': 'Function set type',
                                         'inArgs': [],
                                         'outArgs': [],
                                         'returnInfo': {'doc': 'the class type.',
                                                        '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': 'Adds 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': 'Attaches 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': "Attaches 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': 'Return 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': 'Returns the name of this class.',
                                              'inArgs': [],
                                              'outArgs': [],
                                              'returnInfo': {'doc': 'Name of this class.',
                                                             'qualifiers': ['*'],
                                                             'type': 'char'},
                                              'returnType': 'char',
                                              'static': True,
                                              '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': "Creates 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': {'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': 'Return 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': {},
                                             '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': 'Returns 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': ['&']},
                                                  'types': {'clip1': 'MObject',
                                                            'clip2': 'MObject',
                                                            'index': 'int'}}],
                               'getBlendCount': [{'argInfo': {},
                                                  'args': [],
                                                  'defaults': {},
                                                  'deprecated': False,
                                                  'doc': 'Return 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': {},
                                                  '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': 'Given 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': 'Get 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': {},
                                                     'types': {}}],
                               'getMemberPlugs': [{'argInfo': {'result': {'doc': 'storage for the returned list of members',
                                                                          'type': 'MPlugArray'}},
                                                   'args': [('result',
                                                             'MPlugArray',
                                                             'out')],
                                                   'defaults': {},
                                                   'deprecated': False,
                                                   'doc': 'Get 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': 'Return 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': {},
                                                     'types': {'index': 'int'}}],
                               'getScheduledClipCount': [{'argInfo': {},
                                                          'args': [],
                                                          'defaults': {},
                                                          'deprecated': False,
                                                          'doc': 'Return 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': {},
                                                          'types': {}}],
                               'getSourceClip': [{'argInfo': {'index': {'doc': 'Clip index.',
                                                                        'type': 'int'}},
                                                  'args': [('index',
                                                            'int',
                                                            'in')],
                                                  'defaults': {},
                                                  'deprecated': False,
                                                  'doc': 'Return 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': {},
                                                  'types': {'index': 'int'}}],
                               'getSourceClipCount': [{'argInfo': {},
                                                       'args': [],
                                                       'defaults': {},
                                                       'deprecated': False,
                                                       'doc': 'Return 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': {},
                                                       'types': {}}],
                               'getSubCharacters': [{'argInfo': {'result': {'doc': 'storage for the returned list of members',
                                                                            'type': 'MSelectionList'}},
                                                     'args': [('result',
                                                               'MSelectionList',
                                                               'out')],
                                                     'defaults': {},
                                                     'deprecated': False,
                                                     'doc': 'Get 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': 'Remove 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': {'dgMod': ['&'],
                                                                   'instancedClip1': ['&'],
                                                                   'instancedClip2': ['&']},
                                                'types': {'dgMod': 'MDGModifier',
                                                          'instancedClip1': 'MObject',
                                                          'instancedClip2': 'MObject'}}],
                               'setCommand': [{'argInfo': {},
                                               'args': [],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': '',
                                               'inArgs': [],
                                               'outArgs': [],
                                               'returnInfo': {'doc': '',
                                                              'qualifiers': ['*'],
                                                              'type': ('MFnCharacter',
                                                                       'TsetCmd')},
                                               'returnType': ('MFnCharacter',
                                                              'TsetCmd'),
                                               'static': False,
                                               'typeQualifiers': {},
                                               'types': {}}],
                               'setCommandString': [{'argInfo': {},
                                                     'args': [],
                                                     'defaults': {},
                                                     'deprecated': False,
                                                     'doc': '',
                                                     'inArgs': [],
                                                     'outArgs': [],
                                                     'returnInfo': {'doc': '',
                                                                    'qualifiers': [],
                                                                    'type': ('MFnCharacter',
                                                                             'Tstring')},
                                                     'returnType': ('MFnCharacter',
                                                                    'Tstring'),
                                                     'static': False,
                                                     'typeQualifiers': {},
                                                     'types': {}}],
                               'type': [{'argInfo': {},
                                         'args': [],
                                         'defaults': {},
                                         'deprecated': False,
                                         'doc': 'Function set type',
                                         'inArgs': [],
                                         'outArgs': [],
                                         'returnInfo': {'doc': 'the class type.',
                                                        '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': 'Returns 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': 'uint'},
                                                      'returnType': 'uint',
                                                      'static': False,
                                                      'typeQualifiers': {},
                                                      'types': {}}],
                                      'axisIndex': [{'argInfo': {},
                                                     'args': [],
                                                     'defaults': {},
                                                     'deprecated': False,
                                                     'doc': 'Returns 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': 'uint'},
                                                     'returnType': 'uint',
                                                     'static': False,
                                                     'typeQualifiers': {},
                                                     'types': {}}],
                                      'centerIndex': [{'argInfo': {},
                                                       'args': [],
                                                       'defaults': {},
                                                       'deprecated': False,
                                                       'doc': 'Returns 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': 'uint'},
                                                       'returnType': 'uint',
                                                       'static': False,
                                                       'typeQualifiers': {},
                                                       'types': {}}],
                                      'className': [{'argInfo': {},
                                                     'args': [],
                                                     'defaults': {},
                                                     'deprecated': False,
                                                     'doc': 'Returns the name of this class.',
                                                     'inArgs': [],
                                                     'outArgs': [],
                                                     'returnInfo': {'doc': 'Name of this class.',
                                                                    'qualifiers': ['*'],
                                                                    'type': 'char'},
                                                     'returnType': 'char',
                                                     'static': True,
                                                     'typeQualifiers': {},
                                                     'types': {}}],
                                      'connectToAnglePlug': [{'argInfo': {'anglePlug': {'doc': 'the angle plug',
                                                                                        'type': 'MPlug'}},
                                                              'args': [('anglePlug',
                                                                        'MPlug',
                                                                        'in')],
                                                              'defaults': {},
                                                              'deprecated': False,
                                                              'doc': 'Connect 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': "Creates 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': {},
                                                  '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': "Creates 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': {'angleName': ['const',
                                                                                   '&'],
                                                                     'manipName': ['const',
                                                                                   '&']},
                                                  'types': {'angleName': 'MString',
                                                            'manipName': 'MString'}}],
                                      'endCircleIndex': [{'argInfo': {},
                                                          'args': [],
                                                          'defaults': {},
                                                          'deprecated': False,
                                                          'doc': 'Returns 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': 'uint'},
                                                          'returnType': 'uint',
                                                          'static': False,
                                                          'typeQualifiers': {},
                                                          'types': {}}],
                                      'endPoint': [{'argInfo': {},
                                                    'args': [],
                                                    'defaults': {},
                                                    'deprecated': False,
                                                    'doc': 'Returns the end point.',
                                                    'inArgs': [],
                                                    'inverse': ('setEndPoint',
                                                                False),
                                                    'outArgs': [],
                                                    'returnInfo': {'doc': 'The end point',
                                                                   'qualifiers': [],
                                                                   'type': 'MPoint'},
                                                    'returnType': 'MPoint',
                                                    'static': False,
                                                    'typeQualifiers': {},
                                                    'types': {}}],
                                      'setAngle': [{'argInfo': {'angle': {'doc': 'the angle of the CircleSweepManip',
                                                                          'type': 'MAngle'}},
                                                    'args': [('angle',
                                                              'MAngle',
                                                              'in')],
                                                    'defaults': {},
                                                    'deprecated': False,
                                                    'doc': 'Sets the angle of the CircleSweepManip.',
                                                    'inArgs': ['angle'],
                                                    'outArgs': [],
                                                    'returnInfo': {'doc': '',
                                                                   'qualifiers': [],
                                                                   'type': None},
                                                    'returnType': None,
                                                    'static': False,
                                                    'typeQualifiers': {},
                                                    'types': {'angle': 'MAngle'}}],
                                      'setCenterPoint': [{'argInfo': {'centerPoint': {'doc': 'the center point of the CircleSweepManip',
                                                                                      'type': 'MPoint'}},
                                                          'args': [('centerPoint',
                                                                    'MPoint',
                                                                    'in')],
                                                          'defaults': {},
                                                          'deprecated': False,
                                                          'doc': 'Sets 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': 'Sets whether or not to draw as arc.',
                                                        'inArgs': ['state'],
                                                        'outArgs': [],
                                                        'returnInfo': {'doc': '',
                                                                       'qualifiers': [],
                                                                       'type': None},
                                                        'returnType': None,
                                                        'static': False,
                                                        'typeQualifiers': {},
                                                        'types': {'state': 'bool'}}],
                                      'setEndPoint': [{'argInfo': {'endPoint': {'doc': 'the end point of the CircleSweepManip',
                                                                                'type': 'MPoint'}},
                                                       'args': [('endPoint',
                                                                 'MPoint',
                                                                 'in')],
                                                       'defaults': {},
                                                       'deprecated': False,
                                                       'doc': 'Sets 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': 'Sets 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': 'Sets the radius of the CircleSweepManip.',
                                                     'inArgs': ['radius'],
                                                     'outArgs': [],
                                                     'returnInfo': {'doc': '',
                                                                    'qualifiers': [],
                                                                    'type': None},
                                                     'returnType': None,
                                                     'static': False,
                                                     'typeQualifiers': {},
                                                     'types': {'radius': 'double'}}],
                                      'setStartPoint': [{'argInfo': {'startPoint': {'doc': 'the start point of the CircleSweepManip',
                                                                                    'type': 'MPoint'}},
                                                         'args': [('startPoint',
                                                                   'MPoint',
                                                                   'in')],
                                                         'defaults': {},
                                                         'deprecated': False,
                                                         'doc': 'Sets 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': 'Returns 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': 'uint'},
                                                            'returnType': 'uint',
                                                            'static': False,
                                                            'typeQualifiers': {},
                                                            'types': {}}],
                                      'startPoint': [{'argInfo': {},
                                                      'args': [],
                                                      'defaults': {},
                                                      'deprecated': False,
                                                      'doc': 'Returns the start point.',
                                                      'inArgs': [],
                                                      'inverse': ('setStartPoint',
                                                                  False),
                                                      'outArgs': [],
                                                      'returnInfo': {'doc': 'The start point',
                                                                     'qualifiers': [],
                                                                     'type': 'MPoint'},
                                                      'returnType': 'MPoint',
                                                      'static': False,
                                                      'typeQualifiers': {},
                                                      'types': {}}],
                                      'type': [{'argInfo': {},
                                                'args': [],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': 'Function set type',
                                                'inArgs': [],
                                                'outArgs': [],
                                                'returnInfo': {'doc': 'the class type.',
                                                               'qualifiers': [],
                                                               'type': ('MFn',
                                                                        'Type')},
                                                'returnType': ('MFn', 'Type'),
                                                'static': False,
                                                'typeQualifiers': {},
                                                'types': {}}]},
                          'pymelEnums': {},
                          'pymelMethods': {'endPoint': 'getEndPoint',
                                           'startPoint': 'getStartPoint'}},
  'MFnClip': {'enums': {},
              'invertibles': [('setAbsolute', 'getAbsolute'),
                              ('setAbsoluteChannelSettings',
                               'getAbsoluteChannelSettings'),
                              ('setCycle', 'getCycle'),
                              ('setEnabled', 'getEnabled'),
                              ('setPostCycle', 'getPostCycle'),
                              ('setPreCycle', 'getPreCycle'),
                              ('setScale', 'getScale'),
                              ('setStartFrame', 'getStartFrame'),
                              ('setTrack', 'getTrack'),
                              ('setWeight', 'getWeight')],
              'methods': {'className': [{'argInfo': {},
                                         'args': [],
                                         'defaults': {},
                                         'deprecated': False,
                                         'doc': 'Returns the name of this class.',
                                         'inArgs': [],
                                         'outArgs': [],
                                         'returnInfo': {'doc': 'Name of this class.',
                                                        'qualifiers': ['*'],
                                                        'type': 'char'},
                                         'returnType': 'char',
                                         'static': True,
                                         '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': 'Creates 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': {'dgMod': ['&'],
                                                                      'sourceClip': ['&'],
                                                                      'start': ['const',
                                                                                '&']},
                                                   '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': "Creates 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': {'dgMod': ['&'],
                                                                   'sourceDuration': ['const',
                                                                                      '&'],
                                                                   'sourceStart': ['const',
                                                                                   '&']},
                                                'types': {'dgMod': 'MDGModifier',
                                                          'sourceDuration': 'MTime',
                                                          'sourceStart': 'MTime'}}],
                          'getAbsolute': [{'argInfo': {},
                                           'args': [],
                                           'defaults': {},
                                           'deprecated': True,
                                           'doc': 'This method is obsolete. [from before Maya 2016]',
                                           'inArgs': [],
                                           'inverse': ('setAbsolute', False),
                                           'outArgs': [],
                                           'returnInfo': {'doc': "The value of this clip's offset attribute.",
                                                          'qualifiers': [],
                                                          'type': 'bool'},
                                           'returnType': 'bool',
                                           'static': False,
                                           'typeQualifiers': {},
                                           'types': {}}],
                          'getAbsoluteChannelSettings': [{'argInfo': {'absoluteChannels': {'doc': 'array to store the result',
                                                                                           'type': 'MIntArray'}},
                                                          'args': [('absoluteChannels',
                                                                    'MIntArray',
                                                                    'out')],
                                                          'defaults': {},
                                                          'deprecated': False,
                                                          'doc': 'Return 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': 'This method is obsolete. [from before Maya 2016]',
                                        'inArgs': [],
                                        'inverse': ('setCycle', False),
                                        'outArgs': [],
                                        'returnInfo': {'doc': "The value of this clip's cycle attribute.",
                                                       'qualifiers': [],
                                                       'type': 'double'},
                                        'returnType': 'double',
                                        'static': False,
                                        'typeQualifiers': {},
                                        'types': {}}],
                          'getEnabled': [{'argInfo': {},
                                          'args': [],
                                          'defaults': {},
                                          'deprecated': False,
                                          'doc': "Return 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': {},
                                          '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': 'Return 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': "Return 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': {},
                                            'types': {}}],
                          'getPreCycle': [{'argInfo': {},
                                           'args': [],
                                           'defaults': {},
                                           'deprecated': False,
                                           'doc': "Return 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': {},
                                           'types': {}}],
                          'getScale': [{'argInfo': {},
                                        'args': [],
                                        'defaults': {},
                                        'deprecated': False,
                                        'doc': "Return 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': {},
                                        'types': {}}],
                          'getSourceDuration': [{'argInfo': {},
                                                 'args': [],
                                                 'defaults': {},
                                                 'deprecated': False,
                                                 'doc': "Return 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': {},
                                                 'types': {}}],
                          'getSourceStart': [{'argInfo': {},
                                              'args': [],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': "Return 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': {},
                                              'types': {}}],
                          'getStartFrame': [{'argInfo': {},
                                             'args': [],
                                             'defaults': {},
                                             'deprecated': False,
                                             'doc': "Return 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': {},
                                             'types': {}}],
                          'getTrack': [{'argInfo': {},
                                        'args': [],
                                        'defaults': {},
                                        'deprecated': False,
                                        'doc': 'Return 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': {},
                                        'types': {}}],
                          'getWeight': [{'argInfo': {},
                                         'args': [],
                                         'defaults': {},
                                         'deprecated': False,
                                         'doc': "Return 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': {},
                                         'types': {}}],
                          'isInstancedClip': [{'argInfo': {},
                                               'args': [],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': 'Return 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': {},
                                               'types': {}}],
                          'isPose': [{'argInfo': {},
                                      'args': [],
                                      'defaults': {},
                                      'deprecated': False,
                                      'doc': 'Return 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': {},
                                      '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': 'This method is obsolete. [from before Maya 2016]',
                                           'inArgs': ['abs', 'mod'],
                                           'inverse': ('getAbsolute', True),
                                           'outArgs': [],
                                           'returnInfo': {'doc': '',
                                                          'qualifiers': [],
                                                          'type': None},
                                           'returnType': None,
                                           'static': False,
                                           'typeQualifiers': {'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': 'Set 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': 'This method is obsolete. [from before Maya 2016]',
                                        'inArgs': ['cycle', 'mod'],
                                        'inverse': ('getCycle', True),
                                        'outArgs': [],
                                        'returnInfo': {'doc': '',
                                                       'qualifiers': [],
                                                       'type': None},
                                        'returnType': None,
                                        'static': False,
                                        'typeQualifiers': {'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': 'Specify 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': ['*']},
                                          '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': 'Specify 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': ['*']},
                                           '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': 'Specify the post cycle value for the clip.',
                                            'inArgs': ['cycle', 'mod'],
                                            'inverse': ('getPostCycle', True),
                                            'outArgs': [],
                                            'returnInfo': {'doc': '',
                                                           'qualifiers': [],
                                                           'type': None},
                                            'returnType': None,
                                            'static': False,
                                            'typeQualifiers': {'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': 'Specify the pre cycle value for the clip.',
                                           'inArgs': ['cycle', 'mod'],
                                           'inverse': ('getPreCycle', True),
                                           'outArgs': [],
                                           'returnInfo': {'doc': '',
                                                          'qualifiers': [],
                                                          'type': None},
                                           'returnType': None,
                                           'static': False,
                                           'typeQualifiers': {'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': 'Specify a scale value for the clip.',
                                        'inArgs': ['scale', 'mod'],
                                        'inverse': ('getScale', True),
                                        'outArgs': [],
                                        'returnInfo': {'doc': '',
                                                       'qualifiers': [],
                                                       'type': None},
                                        'returnType': None,
                                        'static': False,
                                        'typeQualifiers': {'mod': ['*']},
                                        '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': 'Specify 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': 'Specify 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': 'Specify 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': ['*']},
                                        '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': 'Specify a weight value for the clip.',
                                         'inArgs': ['wt', 'mod'],
                                         'inverse': ('getWeight', True),
                                         'outArgs': [],
                                         'returnInfo': {'doc': '',
                                                        'qualifiers': [],
                                                        'type': None},
                                         'returnType': None,
                                         'static': False,
                                         'typeQualifiers': {'mod': ['*']},
                                         'types': {'mod': 'MDGModifier',
                                                   'wt': 'double'}}],
                          'sourceClip': [{'argInfo': {},
                                          'args': [],
                                          'defaults': {},
                                          'deprecated': False,
                                          'doc': "Return 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': {},
                                          'types': {}}],
                          'type': [{'argInfo': {},
                                    'args': [],
                                    'defaults': {},
                                    'deprecated': False,
                                    'doc': 'Function set type',
                                    'inArgs': [],
                                    'outArgs': [],
                                    'returnInfo': {'doc': 'the class type.',
                                                   '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': 'Returns the name of this class.',
                                              'inArgs': [],
                                              'outArgs': [],
                                              'returnInfo': {'doc': 'Name of this class.',
                                                             'qualifiers': ['*'],
                                                             'type': 'char'},
                                              'returnType': 'char',
                                              'static': True,
                                              'typeQualifiers': {},
                                              'types': {}}],
                               'componentType': [{'argInfo': {},
                                                  'args': [],
                                                  'defaults': {},
                                                  'deprecated': False,
                                                  'doc': 'Returns the MFn type of the component.',
                                                  'inArgs': [],
                                                  'outArgs': [],
                                                  'returnInfo': {'doc': 'The type',
                                                                 'qualifiers': [],
                                                                 'type': ('MFn',
                                                                          'Type')},
                                                  'returnType': ('MFn', 'Type'),
                                                  'static': False,
                                                  'typeQualifiers': {},
                                                  'types': {}}],
                               'elementCount': [{'argInfo': {},
                                                 'args': [],
                                                 'defaults': {},
                                                 'deprecated': False,
                                                 'doc': 'Returns the number of elements that this component contains.',
                                                 'inArgs': [],
                                                 'outArgs': [],
                                                 'returnInfo': {'doc': 'The number of elements',
                                                                'qualifiers': [],
                                                                'type': 'int'},
                                                 'returnType': 'int',
                                                 'static': False,
                                                 'typeQualifiers': {},
                                                 'types': {}}],
                               'hasWeights': [{'argInfo': {},
                                               'args': [],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': 'Query 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': 'True if the component includes weight data, false otherwise',
                                                              'qualifiers': [],
                                                              'type': 'bool'},
                                               'returnType': 'bool',
                                               'static': False,
                                               'typeQualifiers': {},
                                               'types': {}}],
                               'isComplete': [{'argInfo': {},
                                               'args': [],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': 'Returns 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': {},
                                               'types': {}}],
                               'isEmpty': [{'argInfo': {},
                                            'args': [],
                                            'defaults': {},
                                            'deprecated': False,
                                            'doc': 'Determines 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': {},
                                            'types': {}}],
                               'isEqual': [{'argInfo': {'component': {'doc': 'component to compare',
                                                                      'type': 'MObject'}},
                                            'args': [('component',
                                                      'MObject',
                                                      'in')],
                                            'defaults': {},
                                            'deprecated': False,
                                            'doc': 'Compares 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': {'component': ['&']},
                                            'types': {'component': 'MObject'}}],
                               'setComplete': [{'argInfo': {'complete': {'doc': 'true sets the component as complete',
                                                                         'type': 'bool'}},
                                                'args': [('complete',
                                                          'bool',
                                                          'in')],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': 'Sets the complete state of the component.',
                                                'inArgs': ['complete'],
                                                'inverse': ('isComplete', True),
                                                'outArgs': [],
                                                'returnInfo': {'doc': '',
                                                               'qualifiers': [],
                                                               'type': None},
                                                'returnType': None,
                                                'static': False,
                                                'typeQualifiers': {},
                                                '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': 'Set 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': {'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': 'Set 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': 'Function set type',
                                         'inArgs': [],
                                         'outArgs': [],
                                         'returnInfo': {'doc': 'the class type.',
                                                        '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': 'Return 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': {},
                                           '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': 'Extract 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': 'Add 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': 'Returns the name of this class.',
                                                      'inArgs': [],
                                                      'outArgs': [],
                                                      'returnInfo': {'doc': 'Name of this class.',
                                                                     'qualifiers': ['*'],
                                                                     'type': 'char'},
                                                      'returnType': 'char',
                                                      'static': True,
                                                      'typeQualifiers': {},
                                                      'types': {}}],
                                       'clear': [{'argInfo': {},
                                                  'args': [],
                                                  'defaults': {},
                                                  'deprecated': False,
                                                  'doc': 'Remove 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': 'Create 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': {},
                                                   'types': {}}],
                                       'has': [{'argInfo': {'obj': {'doc': 'the MObject containing the component to look for',
                                                                    'type': 'MObject'}},
                                                'args': [('obj',
                                                          'MObject',
                                                          'in')],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': 'Determine 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': {'obj': ['const',
                                                                           '&']},
                                                'types': {'obj': 'MObject'}}],
                                       'length': [{'argInfo': {},
                                                   'args': [],
                                                   'defaults': {},
                                                   'deprecated': False,
                                                   'doc': 'Return the number of components in the instance.',
                                                   'inArgs': [],
                                                   'outArgs': [],
                                                   'returnInfo': {'doc': 'The number of components in the instance',
                                                                  'qualifiers': [],
                                                                  'type': 'uint'},
                                                   'returnType': 'uint',
                                                   'static': False,
                                                   'typeQualifiers': {},
                                                   'types': {}}],
                                       'remove': [{'argInfo': {'obj': {'doc': 'an MObject containing the component to remove',
                                                                       'type': 'MObject'}},
                                                   'args': [('obj',
                                                             'MObject',
                                                             'in')],
                                                   'defaults': {},
                                                   'deprecated': False,
                                                   'doc': 'Remove 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': 'Remove 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': 'Function set type',
                                                 'inArgs': [],
                                                 'outArgs': [],
                                                 'returnInfo': {'doc': 'the class type.',
                                                                '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': 'Add 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': 'Get a child of this compound attribute.',
                                                  'inArgs': ['index'],
                                                  'outArgs': [],
                                                  'returnInfo': {'doc': 'The child attribute',
                                                                 'qualifiers': [],
                                                                 'type': 'MObject'},
                                                  'returnType': 'MObject',
                                                  'static': False,
                                                  'typeQualifiers': {'index': ['unsigned']},
                                                  'types': {'index': 'uint'}}],
                                       'className': [{'argInfo': {},
                                                      'args': [],
                                                      'defaults': {},
                                                      'deprecated': False,
                                                      'doc': 'Returns the name of this class.',
                                                      'inArgs': [],
                                                      'outArgs': [],
                                                      'returnInfo': {'doc': 'Name of this class.',
                                                                     'qualifiers': ['*'],
                                                                     'type': 'char'},
                                                      'returnType': 'char',
                                                      'static': True,
                                                      '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': 'Creates a new compound attribute.',
                                                   'inArgs': ['full', 'brief'],
                                                   'outArgs': [],
                                                   'returnInfo': {'doc': 'Return status',
                                                                  'qualifiers': [],
                                                                  'type': 'MObject'},
                                                   'returnType': 'MObject',
                                                   'static': False,
                                                   'typeQualifiers': {'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': 'Returns 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': ['&']},
                                                           'types': {'cmds': 'MStringArray',
                                                                     'useLongNames': 'bool'}}],
                                       'numChildren': [{'argInfo': {},
                                                        'args': [],
                                                        'defaults': {},
                                                        'deprecated': False,
                                                        'doc': 'Returns the number of child attributes that this compound attribute has.',
                                                        'inArgs': [],
                                                        'outArgs': [],
                                                        'returnInfo': {'doc': 'The number of children',
                                                                       'qualifiers': [],
                                                                       'type': 'uint'},
                                                        'returnType': 'uint',
                                                        'static': False,
                                                        'typeQualifiers': {},
                                                        'types': {}}],
                                       'removeChild': [{'argInfo': {'child': {'doc': 'child attribute to remove',
                                                                              'type': 'MObject'}},
                                                        'args': [('child',
                                                                  'MObject',
                                                                  'in')],
                                                        'defaults': {},
                                                        'deprecated': False,
                                                        'doc': 'Remove 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': 'Function set type',
                                                 'inArgs': [],
                                                 'outArgs': [],
                                                 'returnInfo': {'doc': 'the class type.',
                                                                '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': 'Returns the name of this class.',
                                                  'inArgs': [],
                                                  'outArgs': [],
                                                  'returnInfo': {'doc': 'Name of this class.',
                                                                 'qualifiers': ['*'],
                                                                 'type': 'char'},
                                                  'returnType': 'char',
                                                  'static': True,
                                                  'typeQualifiers': {},
                                                  'types': {}}],
                                   'clear': [{'argInfo': {},
                                              'args': [],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': 'Delete 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': 'Retrieve the current container node.',
                                                            'inArgs': [],
                                                            'outArgs': [],
                                                            'returnInfo': {'doc': 'The current container node if one has been set. Returns MObject::kNullObj otherwise.',
                                                                           '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': 'Return 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': 'Return 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': 'Return 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': ['&']},
                                                          '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': 'Return 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': ['&']},
                                                          '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': 'Return 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': 'Return 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': 'Return 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': 'Return 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': {},
                                                  'types': {}}],
                                   'makeCurrent': [{'argInfo': {'isCurrent': {'doc': 'Specifies whether this container shall be current',
                                                                              'type': 'bool'}},
                                                    'args': [('isCurrent',
                                                              'bool',
                                                              'in')],
                                                    'defaults': {'isCurrent': True},
                                                    'deprecated': False,
                                                    'doc': 'Set 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': {},
                                                    'types': {'isCurrent': 'bool'}}],
                                   'type': [{'argInfo': {},
                                             'args': [],
                                             'defaults': {},
                                             'deprecated': False,
                                             'doc': 'Function set type',
                                             'inArgs': [],
                                             'outArgs': [],
                                             'returnInfo': {'doc': 'the class type.',
                                                            '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': [('setEndParameter', 'endParameter'),
                                           ('setStartParameter',
                                            'startParameter')],
                           'methods': {'className': [{'argInfo': {},
                                                      'args': [],
                                                      'defaults': {},
                                                      'deprecated': False,
                                                      'doc': 'Returns the name of this class.',
                                                      'inArgs': [],
                                                      'outArgs': [],
                                                      'returnInfo': {'doc': 'Name of this class.',
                                                                     'qualifiers': ['*'],
                                                                     'type': 'char'},
                                                      'returnType': 'char',
                                                      'static': True,
                                                      'typeQualifiers': {},
                                                      'types': {}}],
                                       'connectToCurvePlug': [{'argInfo': {'curvePlug': {'doc': 'the curve plug',
                                                                                         'type': 'MPlug'}},
                                                               'args': [('curvePlug',
                                                                         'MPlug',
                                                                         'in')],
                                                               'defaults': {},
                                                               'deprecated': False,
                                                               'doc': 'Connect 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': 'Connect 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': 'Connect 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': "Creates 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': {},
                                                   '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': "Creates 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': {'endParamName': ['const',
                                                                                       '&'],
                                                                      'manipName': ['const',
                                                                                    '&'],
                                                                      'startParamName': ['const',
                                                                                         '&']},
                                                   'types': {'endParamName': 'MString',
                                                             'manipName': 'MString',
                                                             'startParamName': 'MString'}}],
                                       'curveIndex': [{'argInfo': {},
                                                       'args': [],
                                                       'defaults': {},
                                                       'deprecated': False,
                                                       'doc': 'Returns the index of the curve. The data type corresponding to this index is MFnData::kNurbsCurve.',
                                                       'inArgs': [],
                                                       'outArgs': [],
                                                       'returnInfo': {'doc': 'Curve index',
                                                                      'qualifiers': [],
                                                                      'type': 'uint'},
                                                       'returnType': 'uint',
                                                       'static': False,
                                                       'typeQualifiers': {},
                                                       'types': {}}],
                                       'endParamIndex': [{'argInfo': {},
                                                          'args': [],
                                                          'defaults': {},
                                                          'deprecated': False,
                                                          'doc': 'Returns 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': 'uint'},
                                                          'returnType': 'uint',
                                                          'static': False,
                                                          'typeQualifiers': {},
                                                          'types': {}}],
                                       'endParameter': [{'argInfo': {},
                                                         'args': [],
                                                         'defaults': {},
                                                         'deprecated': False,
                                                         'doc': 'Returns the end parameter.',
                                                         'inArgs': [],
                                                         'inverse': ('setEndParameter',
                                                                     False),
                                                         'outArgs': [],
                                                         'returnInfo': {'doc': 'End parameter',
                                                                        'qualifiers': [],
                                                                        'type': 'double'},
                                                         'returnType': 'double',
                                                         'static': False,
                                                         'typeQualifiers': {},
                                                         'types': {}}],
                                       'setEndParameter': [{'argInfo': {'endParameter': {'doc': 'the end parameter',
                                                                                         'type': 'double'}},
                                                            'args': [('endParameter',
                                                                      'double',
                                                                      'in')],
                                                            'defaults': {},
                                                            'deprecated': False,
                                                            'doc': 'Sets the end parameter.',
                                                            'inArgs': ['endParameter'],
                                                            'inverse': ('endParameter',
                                                                        True),
                                                            'outArgs': [],
                                                            'returnInfo': {'doc': '',
                                                                           'qualifiers': [],
                                                                           'type': None},
                                                            'returnType': None,
                                                            'static': False,
                                                            'typeQualifiers': {},
                                                            'types': {'endParameter': 'double'}}],
                                       'setStartParameter': [{'argInfo': {'startParameter': {'doc': 'the start parameter',
                                                                                             'type': 'double'}},
                                                              'args': [('startParameter',
                                                                        'double',
                                                                        'in')],
                                                              'defaults': {},
                                                              'deprecated': False,
                                                              'doc': 'Sets the start parameter.',
                                                              'inArgs': ['startParameter'],
                                                              'inverse': ('startParameter',
                                                                          True),
                                                              'outArgs': [],
                                                              'returnInfo': {'doc': '',
                                                                             'qualifiers': [],
                                                                             'type': None},
                                                              'returnType': None,
                                                              'static': False,
                                                              'typeQualifiers': {},
                                                              'types': {'startParameter': 'double'}}],
                                       'startParamIndex': [{'argInfo': {},
                                                            'args': [],
                                                            'defaults': {},
                                                            'deprecated': False,
                                                            'doc': 'Returns 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': 'uint'},
                                                            'returnType': 'uint',
                                                            'static': False,
                                                            'typeQualifiers': {},
                                                            'types': {}}],
                                       'startParameter': [{'argInfo': {},
                                                           'args': [],
                                                           'defaults': {},
                                                           'deprecated': False,
                                                           'doc': 'Returns the start parameter.',
                                                           'inArgs': [],
                                                           'inverse': ('setStartParameter',
                                                                       False),
                                                           'outArgs': [],
                                                           'returnInfo': {'doc': 'start parameter',
                                                                          'qualifiers': [],
                                                                          'type': 'double'},
                                                           'returnType': 'double',
                                                           'static': False,
                                                           'typeQualifiers': {},
                                                           'types': {}}],
                                       'type': [{'argInfo': {},
                                                 'args': [],
                                                 'defaults': {},
                                                 'deprecated': False,
                                                 'doc': 'Function set type',
                                                 'inArgs': [],
                                                 'outArgs': [],
                                                 'returnInfo': {'doc': 'the class type.',
                                                                'qualifiers': [],
                                                                'type': ('MFn',
                                                                         'Type')},
                                                 'returnType': ('MFn', 'Type'),
                                                 'static': False,
                                                 'typeQualifiers': {},
                                                 'types': {}}]},
                           'pymelEnums': {},
                           'pymelMethods': {'endParameter': 'getEndParameter',
                                            'startParameter': 'getStartParameter'}},
  'MFnDagNode': {'constants': {'kNextPos': 255},
                 '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'),
                                 ('setIntermediateObject',
                                  'isIntermediateObject'),
                                 ('setObjectColor', 'objectColor'),
                                 ('setObjectColorType', 'objectColorType')],
                 'methods': {'activeColor': [{'argInfo': {},
                                              'args': [],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': 'Determines 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': {},
                                              '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': 255,
                                                        'keepExistingParents': False},
                                           'deprecated': False,
                                           'doc': 'Makes 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']},
                                           'types': {'child': 'MObject',
                                                     'index': 'uint',
                                                     'keepExistingParents': 'bool'}}],
                             'boundingBox': [{'argInfo': {},
                                              'args': [],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': 'Returns 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': {},
                                              'types': {}}],
                             'child': [{'argInfo': {'i': {'doc': 'Index to the child Node',
                                                          'type': 'uint'}},
                                        'args': [('i', 'uint', 'in')],
                                        'defaults': {},
                                        'deprecated': False,
                                        'doc': 'Queries 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': {'i': ['unsigned']},
                                        'types': {'i': 'uint'}}],
                             'childCount': [{'argInfo': {},
                                             'args': [],
                                             'defaults': {},
                                             'deprecated': False,
                                             'doc': 'Determines 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': 'uint'},
                                             'returnType': 'uint',
                                             'static': False,
                                             'typeQualifiers': {},
                                             'types': {}}],
                             'className': [{'argInfo': {},
                                            'args': [],
                                            'defaults': {},
                                            'deprecated': False,
                                            'doc': 'Returns the name of this class.',
                                            'inArgs': [],
                                            'outArgs': [],
                                            'returnInfo': {'doc': 'Name of this class.',
                                                           'qualifiers': ['*'],
                                                           'type': 'char'},
                                            'returnType': 'char',
                                            'static': True,
                                            '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': 'Creates 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': {'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': 'Creates 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': {'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': 'Creates 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': {'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': 'Creates 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': {'name': ['const',
                                                                     '&'],
                                                            'parent': ['&'],
                                                            'type': ['const',
                                                                     '&']},
                                         'types': {'name': 'MString',
                                                   'parent': 'MObject',
                                                   'type': 'MString'}}],
                             'dagPath': [{'argInfo': {},
                                          'args': [],
                                          'defaults': {},
                                          'deprecated': False,
                                          'doc': 'Returns 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': {},
                                          'types': {}}],
                             'dagRoot': [{'argInfo': {},
                                          'args': [],
                                          'defaults': {},
                                          'deprecated': False,
                                          'doc': 'Determines 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': {},
                                          'types': {}}],
                             'dormantColor': [{'argInfo': {},
                                               'args': [],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': 'Determines the dormant color used by this node. The order to determine the dormant color is:',
                                               'inArgs': [],
                                               'outArgs': [],
                                               'returnInfo': {'doc': 'The dormant color.',
                                                              'qualifiers': [],
                                                              'type': 'MColor'},
                                               'returnType': 'MColor',
                                               'static': False,
                                               'typeQualifiers': {},
                                               'types': {}}],
                             'drawOverrideColor': [{'argInfo': {'color': {'doc': 'The draw override color.',
                                                                          'type': 'MColor'}},
                                                    'args': [('color',
                                                              'MColor',
                                                              'out')],
                                                    'defaults': {},
                                                    'deprecated': False,
                                                    'doc': 'Determines 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': {'color': ['&']},
                                                    'types': {'color': 'MColor'}}],
                             'drawOverrideEnabled': [{'argInfo': {},
                                                      'args': [],
                                                      'defaults': {},
                                                      'deprecated': False,
                                                      'doc': 'Determines 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': {},
                                                      'types': {}}],
                             'drawOverrideIsReference': [{'argInfo': {},
                                                          'args': [],
                                                          'defaults': {},
                                                          'deprecated': False,
                                                          'doc': 'Determines 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': {},
                                                          'types': {}}],
                             'drawOverrideIsTemplate': [{'argInfo': {},
                                                         'args': [],
                                                         'defaults': {},
                                                         'deprecated': False,
                                                         'doc': 'Determines 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': {},
                                                         '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': 'This 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': {},
                                            'types': {'instance': 'bool',
                                                      'leafInstance': 'bool'}}],
                             'fullPathName': [{'argInfo': {},
                                               'args': [],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': 'Return 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': {},
                                               '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': 'Determines 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': 'Returns 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'],
                                                                                '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': 'Returns 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': 'Determines 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': {'node': ['const',
                                                                       '&']},
                                           'types': {'node': 'MObject'}}],
                             'hasParent': [{'argInfo': {'node': {'doc': 'Potential parent node',
                                                                 'type': 'MObject'}},
                                            'args': [('node', 'MObject', 'in')],
                                            'defaults': {},
                                            'deprecated': False,
                                            'doc': 'Determines 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': {'node': ['const',
                                                                        '&']},
                                            'types': {'node': 'MObject'}}],
                             'hiliteColor': [{'argInfo': {},
                                              'args': [],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': 'Determines the current hilite color used by the node.',
                                              'inArgs': [],
                                              'outArgs': [],
                                              'returnInfo': {'doc': 'The current hilite color.',
                                                             'qualifiers': [],
                                                             'type': 'MColor'},
                                              'returnType': 'MColor',
                                              'static': False,
                                              'typeQualifiers': {},
                                              'types': {}}],
                             'inModel': [{'argInfo': {},
                                          'args': [],
                                          'defaults': {},
                                          'deprecated': False,
                                          'doc': 'Determines 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': {},
                                          'types': {}}],
                             'inUnderWorld': [{'argInfo': {},
                                               'args': [],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': 'Determines 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': {},
                                               'types': {}}],
                             'instanceCount': [{'argInfo': {'total': {'doc': 'Indirect instance flag',
                                                                      'type': 'bool'}},
                                                'args': [('total',
                                                          'bool',
                                                          'in')],
                                                'defaults': {'total': True},
                                                'deprecated': False,
                                                'doc': 'Determines 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': 'uint'},
                                                'returnType': 'uint',
                                                'static': False,
                                                'typeQualifiers': {},
                                                'types': {'total': 'bool'}}],
                             'isChildOf': [{'argInfo': {'node': {'doc': 'node to check',
                                                                 'type': 'MObject'}},
                                            'args': [('node', 'MObject', 'in')],
                                            'defaults': {},
                                            'deprecated': False,
                                            'doc': 'Determines 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': {'node': ['const',
                                                                        '&']},
                                            'types': {'node': 'MObject'}}],
                             'isInstanceable': [{'argInfo': {},
                                                 'args': [],
                                                 'defaults': {},
                                                 'deprecated': False,
                                                 'doc': 'Returns 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': {},
                                                 'types': {}}],
                             'isInstanced': [{'argInfo': {'indirect': {'doc': 'Indirect instance flag',
                                                                       'type': 'bool'}},
                                              'args': [('indirect',
                                                        'bool',
                                                        'in')],
                                              'defaults': {'indirect': True},
                                              'deprecated': False,
                                              'doc': 'Determines 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': {},
                                              'types': {'indirect': 'bool'}}],
                             'isInstancedAttribute': [{'argInfo': {'attribute': {'doc': 'The attribute to test.',
                                                                                 'type': 'MObject'}},
                                                       'args': [('attribute',
                                                                 'MObject',
                                                                 'in')],
                                                       'defaults': {},
                                                       'deprecated': False,
                                                       'doc': 'Returns 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': {'attribute': ['const',
                                                                                        '&']},
                                                       'types': {'attribute': 'MObject'}}],
                             'isIntermediateObject': [{'argInfo': {},
                                                       'args': [],
                                                       'defaults': {},
                                                       'deprecated': False,
                                                       'doc': 'Returns 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': {},
                                                       'types': {}}],
                             'isParentOf': [{'argInfo': {'node': {'doc': 'node to check',
                                                                  'type': 'MObject'}},
                                             'args': [('node',
                                                       'MObject',
                                                       'in')],
                                             'defaults': {},
                                             'deprecated': False,
                                             'doc': 'Determines 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': {'node': ['const',
                                                                         '&']},
                                             'types': {'node': 'MObject'}}],
                             'model': [{'argInfo': {},
                                        'args': [],
                                        'defaults': {},
                                        'deprecated': True,
                                        'doc': 'This method is obsolete. [from before Maya 2016]',
                                        'inArgs': [],
                                        'outArgs': [],
                                        'returnInfo': {'doc': 'The model in which the DAG Node resides.',
                                                       'qualifiers': [],
                                                       'type': 'MObject'},
                                        'returnType': 'MObject',
                                        'static': False,
                                        'typeQualifiers': {},
                                        'types': {}}],
                             'objectColor': [{'argInfo': {},
                                              'args': [],
                                              'defaults': {},
                                              'deprecated': True,
                                              'doc': 'This method is obsolete. [as of Maya 2016]',
                                              'inArgs': [],
                                              'inverse': ('setObjectColor',
                                                          False),
                                              'outArgs': [],
                                              'returnInfo': {'doc': 'Index for current user defined inactive color (0 - 7)',
                                                             'qualifiers': [],
                                                             'type': 'int'},
                                              'returnType': 'int',
                                              'static': False,
                                              'typeQualifiers': {},
                                              'types': {}}],
                             'objectColorIndex': [{'argInfo': {},
                                                   'args': [],
                                                   'defaults': {},
                                                   'deprecated': False,
                                                   'doc': 'Determines 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': {},
                                                   'types': {}}],
                             'objectColorRGB': [{'argInfo': {},
                                                 'args': [],
                                                 'defaults': {},
                                                 'deprecated': False,
                                                 'doc': 'Determines 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': {},
                                                 'types': {}}],
                             'objectColorType': [{'argInfo': {},
                                                  'args': [],
                                                  'defaults': {},
                                                  'deprecated': False,
                                                  'doc': 'Determines 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': {},
                                                  'types': {}}],
                             'objectGroupComponent': [{'argInfo': {'compList': {'doc': '',
                                                                                'type': 'MStringArray'},
                                                                   'groupId': {'doc': '',
                                                                               'type': 'uint'}},
                                                       'args': [('groupId',
                                                                 'uint',
                                                                 'in'),
                                                                ('compList',
                                                                 'MStringArray',
                                                                 'in')],
                                                       'defaults': {},
                                                       'deprecated': False,
                                                       'doc': '',
                                                       'inArgs': ['groupId',
                                                                  'compList'],
                                                       'outArgs': [],
                                                       'returnInfo': {'doc': '',
                                                                      'qualifiers': [],
                                                                      'type': None},
                                                       'returnType': None,
                                                       'static': False,
                                                       'typeQualifiers': {'compList': ['&'],
                                                                          'groupId': ['unsigned']},
                                                       'types': {'compList': 'MStringArray',
                                                                 'groupId': 'uint'}}],
                             'parent': [{'argInfo': {'i': {'doc': 'Index to the parent Node',
                                                           'type': 'uint'}},
                                         'args': [('i', 'uint', 'in')],
                                         'defaults': {},
                                         'deprecated': False,
                                         'doc': 'Queries 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': {'i': ['unsigned']},
                                         'types': {'i': 'uint'}}],
                             'parentCount': [{'argInfo': {},
                                              'args': [],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': 'Determines 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': 'uint'},
                                              'returnType': 'uint',
                                              'static': False,
                                              'typeQualifiers': {},
                                              'types': {}}],
                             'partialPathName': [{'argInfo': {},
                                                  'args': [],
                                                  'defaults': {},
                                                  'deprecated': False,
                                                  'doc': 'Return 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': {},
                                                  'types': {}}],
                             'removeChild': [{'argInfo': {'child': {'doc': 'The Node to be removed as child',
                                                                    'type': 'MObject'}},
                                              'args': [('child',
                                                        'MObject',
                                                        'in')],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': 'Removes 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': 'Removes 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': 'Sets 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': 'Sets 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': {},
                                                        'types': {'isIntermediate': 'bool'}}],
                             'setObject': [{'argInfo': {'objectPath': {'doc': 'DAG Path to Node to be attached.',
                                                                       'type': 'MDagPath'}},
                                            'args': [('objectPath',
                                                      'MDagPath',
                                                      'in')],
                                            'defaults': {},
                                            'deprecated': False,
                                            'doc': 'Attaches 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': 'Attaches 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': 'Sets 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': {},
                                                 'types': {'index': 'int'}},
                                                {'argInfo': {'color': {'doc': 'Color to be set',
                                                                       'type': 'MColor'}},
                                                 'args': [('color',
                                                           'MColor',
                                                           'in')],
                                                 'defaults': {},
                                                 'deprecated': False,
                                                 'doc': 'Sets 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': 'Sets 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': {},
                                                     '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': 'This method is obsolete. [as of Maya 2016]',
                                                    'inArgs': ['useObjectColor'],
                                                    'outArgs': [],
                                                    'returnInfo': {'doc': '',
                                                                   'qualifiers': [],
                                                                   'type': None},
                                                    'returnType': None,
                                                    'static': False,
                                                    'typeQualifiers': {},
                                                    'types': {'useObjectColor': 'bool'}}],
                             'transformationMatrix': [{'argInfo': {},
                                                       'args': [],
                                                       'defaults': {},
                                                       'deprecated': False,
                                                       'doc': 'Returns 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': {},
                                                       'types': {}}],
                             'type': [{'argInfo': {},
                                       'args': [],
                                       'defaults': {},
                                       'deprecated': False,
                                       'doc': 'Function set type',
                                       'inArgs': [],
                                       'outArgs': [],
                                       'returnInfo': {'doc': 'the class type.',
                                                      'qualifiers': [],
                                                      'type': ('MFn', 'Type')},
                                       'returnType': ('MFn', 'Type'),
                                       'static': False,
                                       'typeQualifiers': {},
                                       'types': {}}],
                             'usingHiliteColor': [{'argInfo': {},
                                                   'args': [],
                                                   'defaults': {},
                                                   'deprecated': False,
                                                   'doc': 'Determines 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': {},
                                                   'types': {}}],
                             'usingObjectColor': [{'argInfo': {},
                                                   'args': [],
                                                   'defaults': {},
                                                   'deprecated': True,
                                                   'doc': 'This method is obsolete. [as of Maya 2016]',
                                                   'inArgs': [],
                                                   'outArgs': [],
                                                   'returnInfo': {'doc': 'True if using the user defined inactive object color',
                                                                  'qualifiers': [],
                                                                  'type': 'bool'},
                                                   'returnType': 'bool',
                                                   'static': False,
                                                   'typeQualifiers': {},
                                                   '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 MFnNIdData to extract node data',
                                               'NObject': 'nObject data, use MFnNObjectData to extract node data',
                                               'any': 'Typically used when the data can be one of several types.',
                                               'componentList': 'Component List, use MFnComponentListData to extract the node data.',
                                               'doubleArray': 'Double Array, use MFnDoubleArrayData to extract the node data.',
                                               'dynArrayAttrs': 'ArrayAttrs, use MFnArrayAttrsData to extract the node data.',
                                               'dynSweptGeometry': 'SweptGeometry, use MFnDynSweptGeometryData to extract the node data. This data node is in OpenMayaFX which must be linked to.',
                                               'falloffFunction': 'Last value. It does not represent real data, but can be used to loop on all possible types',
                                               'floatArray': 'Float Array, use MFnFloatArrayData to extract the node data.',
                                               'intArray': 'Int Array, use MFnIntArrayData to extract the node data.',
                                               'invalid': 'Invalid value.',
                                               'kAny': 'Typically used when the data can be one of several types.',
                                               'kComponentList': 'Component List, use MFnComponentListData to extract the node data.',
                                               'kDoubleArray': 'Double Array, use MFnDoubleArrayData to extract the node data.',
                                               'kDynArrayAttrs': 'ArrayAttrs, use MFnArrayAttrsData to extract the node data.',
                                               'kDynSweptGeometry': 'SweptGeometry, use MFnDynSweptGeometryData to extract the node data. This data node is in OpenMayaFX which must be linked to.',
                                               'kFalloffFunction': 'Last value. It does not represent real data, but can be used to loop on all possible types',
                                               'kFloatArray': 'Float Array, use MFnFloatArrayData to extract the node data.',
                                               'kIntArray': 'Int Array, use MFnIntArrayData to extract the node data.',
                                               'kInvalid': 'Invalid value.',
                                               'kLattice': 'Lattice, use MFnLatticeData to extract the node data.',
                                               'kMatrix': 'Matrix, use MFnMatrixData to extract the node data.',
                                               'kMatrixArray': 'Matrix Array, use MFnMatrixArrayData to extract the node data.',
                                               'kMesh': 'Mesh, use MFnMeshData to extract the node data.',
                                               'kNId': 'nId data, use MFnNIdData to extract node data',
                                               'kNObject': 'nObject data, use MFnNObjectData to extract node data',
                                               'kNumeric': 'Numeric, use MFnNumericData extract the node data.',
                                               'kNurbsCurve': 'Nurbs Curve, use MFnNurbsCurveData to extract the node data.',
                                               'kNurbsSurface': 'Nurbs Surface, use MFnNurbsSurfaceData to extract the node data.',
                                               'kPlugin': 'Plugin Blind Data, use MFnPluginData to extract the node data.',
                                               'kPluginGeometry': 'Plugin Geometry, use MFnGeometryData to extract the node data.',
                                               'kPointArray': 'Point Array, use MFnPointArrayData to extract the node data.',
                                               'kSphere': 'Sphere, use MFnSphereData to extract the node data.',
                                               'kString': 'String, use MFnStringData to extract the node data.',
                                               'kStringArray': 'String Array, use MFnStringArrayData to extract the node data.',
                                               'kSubdSurface': 'Subdivision Surface, use MFnSubdData to extract the node data.',
                                               'kVectorArray': 'Vector Array, use MFnVectorArrayData to extract the node data.',
                                               'lattice': 'Lattice, use MFnLatticeData to extract the node data.',
                                               'matrix': 'Matrix, use MFnMatrixData to extract the node data.',
                                               'matrixArray': 'Matrix Array, use MFnMatrixArrayData to extract the node data.',
                                               'mesh': 'Mesh, use MFnMeshData to extract the node data.',
                                               'numeric': 'Numeric, use MFnNumericData extract the node data.',
                                               'nurbsCurve': 'Nurbs Curve, use MFnNurbsCurveData to extract the node data.',
                                               'nurbsSurface': 'Nurbs Surface, use MFnNurbsSurfaceData to extract the node data.',
                                               'plugin': 'Plugin Blind Data, use MFnPluginData to extract the node data.',
                                               'pluginGeometry': 'Plugin Geometry, use MFnGeometryData to extract the node data.',
                                               'pointArray': 'Point Array, use MFnPointArrayData to extract the node data.',
                                               'sphere': 'Sphere, use MFnSphereData to extract the node data.',
                                               'string': 'String, use MFnStringData to extract the node data.',
                                               'stringArray': 'String Array, use MFnStringArrayData to extract the node data.',
                                               'subdSurface': 'Subdivision Surface, use MFnSubdData to extract the node data.',
                                               'vectorArray': 'Vector Array, use MFnVectorArrayData to extract the node data.'},
                                 '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, 'kFalloffFunction': 25, 'kLast': 26})"}},
              'methods': {'className': [{'argInfo': {},
                                         'args': [],
                                         'defaults': {},
                                         'deprecated': False,
                                         'doc': 'Returns the name of this class.',
                                         'inArgs': [],
                                         'outArgs': [],
                                         'returnInfo': {'doc': 'Name of this class.',
                                                        'qualifiers': ['*'],
                                                        'type': 'char'},
                                         'returnType': 'char',
                                         'static': True,
                                         'typeQualifiers': {},
                                         'types': {}}],
                          'type': [{'argInfo': {},
                                    'args': [],
                                    'defaults': {},
                                    'deprecated': False,
                                    'doc': 'Function set type',
                                    'inArgs': [],
                                    'outArgs': [],
                                    'returnInfo': {'doc': 'the class type.',
                                                   '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), ('falloffFunction', 25), ('kFalloffFunction', 25), ('last', 26), ('kLast', 26)], 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': {},
                                                    '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': [('setExternalContent',
                                         'getExternalContent'),
                                        ('setIcon', 'icon'),
                                        ('setLocked', 'isLocked'),
                                        ('setName', 'name'),
                                        ('setUuid', 'uuid')],
                        'methods': {'absoluteName': [{'argInfo': {},
                                                      'args': [],
                                                      'defaults': {},
                                                      'deprecated': False,
                                                      'doc': 'Returns the absolute name of this node.',
                                                      'inArgs': [],
                                                      'outArgs': [],
                                                      'returnInfo': {'doc': 'The absolute name of this node.',
                                                                     'qualifiers': [],
                                                                     'type': 'MString'},
                                                      'returnType': 'MString',
                                                      'static': False,
                                                      'typeQualifiers': {},
                                                      'types': {}}],
                                    'addAttribute': [{'argInfo': {'attr': {'doc': 'new attribute',
                                                                           'type': 'MObject'}},
                                                      'args': [('attr',
                                                                'MObject',
                                                                'in')],
                                                      'defaults': {},
                                                      'deprecated': False,
                                                      'doc': 'Add 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': 'This method is obsolete. [as of Maya 2019]',
                                                      'inArgs': ['attr',
                                                                 'type'],
                                                      'outArgs': [],
                                                      'returnInfo': {'doc': '',
                                                                     'qualifiers': [],
                                                                     'type': None},
                                                      'returnType': None,
                                                      'static': False,
                                                      'typeQualifiers': {'attr': ['const',
                                                                                  '&']},
                                                      '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': 'Adds content info to the specified table from a file path attribute.',
                                                                       'inArgs': ['attr'],
                                                                       'outArgs': ['table'],
                                                                       'returnInfo': {'doc': '',
                                                                                      'qualifiers': [],
                                                                                      'type': None},
                                                                       'returnType': None,
                                                                       'static': False,
                                                                       'typeQualifiers': {'attr': ['const',
                                                                                                   '&'],
                                                                                          'table': ['&']},
                                                                       'types': {'attr': 'MObject',
                                                                                 'table': 'MExternalContentInfoTable'}}],
                                    'affectsAnimation': [{'argInfo': {},
                                                          'args': [],
                                                          'defaults': {},
                                                          'deprecated': False,
                                                          'doc': 'Indicates whether or not this node is allowed to animate. See the setAffectsAnimation method for more information on what it means for a node to be allowed to animate.',
                                                          'inArgs': [],
                                                          'outArgs': [],
                                                          'returnInfo': {'doc': 'true if the node is allowed to animate, false otherwise.',
                                                                         'qualifiers': [],
                                                                         'type': 'bool'},
                                                          'returnType': 'bool',
                                                          'static': False,
                                                          'typeQualifiers': {},
                                                          'types': {}}],
                                    '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': 'Allocates 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': 'uint'},
                                                      'returnType': 'uint',
                                                      'static': True,
                                                      'typeQualifiers': {'pluginName': ['const']},
                                                      'types': {'pluginName': 'MString'}}],
                                    'attribute': [{'argInfo': {'index': {'doc': 'the index of the attribute',
                                                                         'type': 'uint'}},
                                                   'args': [('index',
                                                             'uint',
                                                             'in')],
                                                   'defaults': {},
                                                   'deprecated': False,
                                                   'doc': 'Finds 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': {'index': ['unsigned']},
                                                   'types': {'index': 'uint'}},
                                                  {'argInfo': {'attrName': {'doc': 'name of the attribute to find',
                                                                            'type': 'MString'}},
                                                   'args': [('attrName',
                                                             'MString',
                                                             'in')],
                                                   'defaults': {},
                                                   'deprecated': False,
                                                   'doc': 'Finds 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': {'attrName': ['const',
                                                                                   '&']},
                                                   'types': {'attrName': 'MString'}}],
                                    'attributeClass': [{'argInfo': {'attribute': {'doc': 'the attribute to check',
                                                                                  'type': 'MObject'}},
                                                        'args': [('attribute',
                                                                  'MObject',
                                                                  'in')],
                                                        'defaults': {},
                                                        'deprecated': False,
                                                        'doc': 'Returns 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': {'attribute': ['const',
                                                                                         '&']},
                                                        'types': {'attribute': 'MObject'}}],
                                    'attributeCount': [{'argInfo': {},
                                                        'args': [],
                                                        'defaults': {},
                                                        'deprecated': False,
                                                        'doc': 'Returns the number of attributes that this node has.',
                                                        'inArgs': [],
                                                        'outArgs': [],
                                                        'returnInfo': {'doc': 'The attribute count',
                                                                       'qualifiers': [],
                                                                       'type': 'uint'},
                                                        'returnType': 'uint',
                                                        'static': False,
                                                        'typeQualifiers': {},
                                                        'types': {}}],
                                    'canBeWritten': [{'argInfo': {},
                                                      'args': [],
                                                      'defaults': {},
                                                      'deprecated': False,
                                                      'doc': 'Returns 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': {},
                                                      'types': {}}],
                                    'className': [{'argInfo': {},
                                                   'args': [],
                                                   'defaults': {},
                                                   'deprecated': False,
                                                   'doc': 'Returns the name of this class.',
                                                   'inArgs': [],
                                                   'outArgs': [],
                                                   'returnInfo': {'doc': 'Name of this class.',
                                                                  'qualifiers': ['*'],
                                                                  'type': 'char'},
                                                   'returnType': 'char',
                                                   'static': True,
                                                   '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': 'Retrieves 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': 'Creates 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': {'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': 'Creates 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': {'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': 'Creates 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': {'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': 'Creates 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': {'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': 'Deallocates 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': 'Deallocates 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': 'This 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': 'Node 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': 'The 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': {'timerMetric': ['const'],
                                                                    'timerType': ['const']},
                                                 'types': {'timerMetric': ('MFnDependencyNode',
                                                                           'MdgTimerMetric'),
                                                           'timerType': ('MFnDependencyNode',
                                                                         'MdgTimerType')}}],
                                    'dgTimerOff': [{'argInfo': {},
                                                    'args': [],
                                                    'defaults': {},
                                                    'deprecated': False,
                                                    'doc': 'Indicates 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': 'Indicates 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': "The 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': {},
                                                           'types': {}}],
                                    'dgTimerReset': [{'argInfo': {},
                                                      'args': [],
                                                      'defaults': {},
                                                      'deprecated': False,
                                                      'doc': 'The 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': 'Globally 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': {},
                                                        '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': 'Retrieves 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': {'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': 'Attempt 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': {'attr': ['const',
                                                                              '&']},
                                                  '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': 'Attempt 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': {'attrName': ['const',
                                                                                  '&']},
                                                  'types': {'attrName': 'MString',
                                                            'wantNetworkedPlug': 'bool'}},
                                                 {'argInfo': {'attr': {'doc': 'Attribute to return a plug for.',
                                                                       'type': 'MObject'}},
                                                  'args': [('attr',
                                                            'MObject',
                                                            'in')],
                                                  'defaults': {},
                                                  'deprecated': True,
                                                  'doc': 'This method is obsolete. [as of Maya 2019]',
                                                  'inArgs': ['attr'],
                                                  'outArgs': [],
                                                  'returnInfo': {'doc': '',
                                                                 'qualifiers': [],
                                                                 'type': 'MPlug'},
                                                  'returnType': 'MPlug',
                                                  'static': False,
                                                  'typeQualifiers': {'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': 'This method is obsolete. [as of Maya 2019]',
                                                  'inArgs': ['attrName'],
                                                  'outArgs': [],
                                                  'returnInfo': {'doc': '',
                                                                 'qualifiers': [],
                                                                 'type': 'MPlug'},
                                                  'returnType': 'MPlug',
                                                  'static': False,
                                                  'typeQualifiers': {'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': 'Returns 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': 'Returns 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': "Returns 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': {},
                                                      'types': {'force': 'bool'}}],
                                    'getAliasList': [{'argInfo': {'strArray': {'doc': 'list of aliases',
                                                                               'type': 'MStringArray'}},
                                                      'args': [('strArray',
                                                                'MStringArray',
                                                                'out')],
                                                      'defaults': {},
                                                      'deprecated': False,
                                                      'doc': "Returns 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': {'strArray': ['&']},
                                                      'types': {'strArray': 'MStringArray'}}],
                                    'getConnections': [{'argInfo': {'array': {'doc': 'storage for the array of plugs',
                                                                              'type': 'MPlugArray'}},
                                                        'args': [('array',
                                                                  'MPlugArray',
                                                                  'out')],
                                                        'defaults': {},
                                                        'deprecated': False,
                                                        'doc': 'Get 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': 'Returns the external content (files) that this node depends on.',
                                                            'inArgs': [],
                                                            'inverse': ('setExternalContent',
                                                                        False),
                                                            'outArgs': ['table'],
                                                            'returnInfo': {'doc': '',
                                                                           'qualifiers': [],
                                                                           'type': None},
                                                            'returnType': None,
                                                            'static': False,
                                                            'typeQualifiers': {'table': ['&']},
                                                            'types': {'table': 'MExternalContentInfoTable'}}],
                                    'hasAttribute': [{'argInfo': {'attrName': {'doc': 'Name of attribute to be checked.',
                                                                               'type': 'MString'}},
                                                      'args': [('attrName',
                                                                'MString',
                                                                'in')],
                                                      'defaults': {},
                                                      'deprecated': False,
                                                      'doc': 'Returns 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': {'attrName': ['const',
                                                                                      '&']},
                                                      'types': {'attrName': 'MString'}}],
                                    'hasUniqueName': [{'argInfo': {},
                                                       'args': [],
                                                       'defaults': {},
                                                       'deprecated': False,
                                                       'doc': "Indicates 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': {},
                                                       'types': {}}],
                                    'icon': [{'argInfo': {},
                                              'args': [],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': 'Returns 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': {},
                                              'types': {}}],
                                    'isDefaultNode': [{'argInfo': {},
                                                       'args': [],
                                                       'defaults': {},
                                                       'deprecated': False,
                                                       'doc': 'Returns 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': {},
                                                       'types': {}}],
                                    'isFlagSet': [{'argInfo': {'flag': {'doc': 'number of the flag to retrieve.',
                                                                        'type': 'uint'}},
                                                   'args': [('flag',
                                                             'uint',
                                                             'in')],
                                                   'defaults': {},
                                                   'deprecated': False,
                                                   'doc': 'Retrieves 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': {'flag': ['unsigned']},
                                                   'types': {'flag': 'uint'}}],
                                    'isFromReferencedFile': [{'argInfo': {},
                                                              'args': [],
                                                              'defaults': {},
                                                              'deprecated': False,
                                                              'doc': "Indicates 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': {},
                                                              'types': {}}],
                                    'isLocked': [{'argInfo': {},
                                                  'args': [],
                                                  'defaults': {},
                                                  'deprecated': False,
                                                  'doc': 'Indicates 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': {},
                                                  'types': {}}],
                                    'isNewAttribute': [{'argInfo': {'attr': {'doc': 'Attribute to check.',
                                                                             'type': 'MObject'}},
                                                        'args': [('attr',
                                                                  'MObject',
                                                                  'in')],
                                                        'defaults': {},
                                                        'deprecated': False,
                                                        'doc': 'Indicates 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': {'attr': ['const',
                                                                                    '&']},
                                                        'types': {'attr': 'MObject'}}],
                                    'isShared': [{'argInfo': {},
                                                  'args': [],
                                                  'defaults': {},
                                                  'deprecated': False,
                                                  'doc': 'Indicates 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': {},
                                                  'types': {}}],
                                    'isTrackingEdits': [{'argInfo': {},
                                                         'args': [],
                                                         'defaults': {},
                                                         'deprecated': False,
                                                         'doc': 'Returns 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': {},
                                                         'types': {}}],
                                    'name': [{'argInfo': {},
                                              'args': [],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': 'Returns 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': {},
                                              'types': {}}],
                                    'parentNamespace': [{'argInfo': {},
                                                         'args': [],
                                                         'defaults': {},
                                                         'deprecated': False,
                                                         'doc': 'Returns 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': {},
                                                         'types': {}}],
                                    'pluginName': [{'argInfo': {},
                                                    'args': [],
                                                    'defaults': {},
                                                    'deprecated': False,
                                                    'doc': "Returns 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': {},
                                                    'types': {}}],
                                    'plugsAlias': [{'argInfo': {'plug': {'doc': 'plug for whose attribute we want the alias',
                                                                         'type': 'MPlug'}},
                                                    'args': [('plug',
                                                              'MPlug',
                                                              'in')],
                                                    'defaults': {},
                                                    'deprecated': False,
                                                    'doc': "Returns 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': {'plug': ['const',
                                                                                '&']},
                                                    'types': {'plug': 'MPlug'}}],
                                    'removeAttribute': [{'argInfo': {'attribute': {'doc': 'attribute to remove',
                                                                                   'type': 'MObject'}},
                                                         'args': [('attribute',
                                                                   'MObject',
                                                                   'in')],
                                                         'defaults': {},
                                                         'deprecated': False,
                                                         'doc': 'Remove 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': 'This method is obsolete. [as of Maya 2019]',
                                                         'inArgs': ['attribute',
                                                                    'type'],
                                                         'outArgs': [],
                                                         'returnInfo': {'doc': '',
                                                                        'qualifiers': [],
                                                                        'type': None},
                                                         'returnType': None,
                                                         'static': False,
                                                         'typeQualifiers': {'attribute': ['const',
                                                                                          '&']},
                                                         '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': 'Some 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': {'index': ['unsigned']},
                                                            'types': {'index': 'uint'}}],
                                    'setAffectsAnimation': [{'argInfo': {},
                                                             'args': [],
                                                             'defaults': {},
                                                             'deprecated': False,
                                                             'doc': 'Define a node can affect animation. Normally this is done automatically through the evaluation graph creation process but if you know from the start that your node will definitely participate in animation then you can mark it as such at any point.',
                                                             'inArgs': [],
                                                             'outArgs': [],
                                                             'returnInfo': {'doc': '',
                                                                            'qualifiers': [],
                                                                            'type': None},
                                                             'returnType': None,
                                                             'static': False,
                                                             'typeQualifiers': {},
                                                             'types': {}}],
                                    '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': 'Sets 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': {'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': 'Use 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': {},
                                                       'types': {'flag': 'bool'}}],
                                    'setExternalContent': [{'argInfo': {'table': {'doc': 'Key->location table with new content locations.',
                                                                                  'type': 'MExternalContentLocationTable'}},
                                                            'args': [('table',
                                                                      'MExternalContentLocationTable',
                                                                      'in')],
                                                            'defaults': {},
                                                            'deprecated': False,
                                                            'doc': 'Changes the location of external content.',
                                                            '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': 'Sets content info in the specified attribute from the table.',
                                                                       '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': 'Sets 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']},
                                                 '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': 'Associates 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': 'Locks or unlocks this node.',
                                                   'inArgs': ['lock'],
                                                   'inverse': ('isLocked',
                                                               True),
                                                   'outArgs': [],
                                                   'returnInfo': {'doc': '',
                                                                  'qualifiers': [],
                                                                  'type': None},
                                                   'returnType': None,
                                                   'static': False,
                                                   'typeQualifiers': {},
                                                   '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': 'Sets 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': {'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': "Sets the node's UUID.",
                                                 'inArgs': ['muuid'],
                                                 'inverse': ('uuid', True),
                                                 'outArgs': [],
                                                 'returnInfo': {'doc': '',
                                                                'qualifiers': [],
                                                                'type': None},
                                                 'returnType': None,
                                                 'static': False,
                                                 'typeQualifiers': {'muuid': ['const',
                                                                              '&']},
                                                 'types': {'muuid': 'MUuid'}}],
                                    'type': [{'argInfo': {},
                                              'args': [],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': 'Function set type',
                                              'inArgs': [],
                                              'outArgs': [],
                                              'returnInfo': {'doc': 'the class type.',
                                                             'qualifiers': [],
                                                             'type': ('MFn',
                                                                      'Type')},
                                              'returnType': ('MFn', 'Type'),
                                              'static': False,
                                              'typeQualifiers': {},
                                              'types': {}}],
                                    'typeId': [{'argInfo': {},
                                                'args': [],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': 'Returns 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': {},
                                                'types': {}}],
                                    'typeName': [{'argInfo': {},
                                                  'args': [],
                                                  'defaults': {},
                                                  'deprecated': False,
                                                  'doc': 'Returns 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': {},
                                                  'types': {}}],
                                    'userNode': [{'argInfo': {},
                                                  'args': [],
                                                  'defaults': {},
                                                  'deprecated': False,
                                                  'doc': "If 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': {},
                                                  'types': {}}],
                                    'uuid': [{'argInfo': {},
                                              'args': [],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': "Returns the node's UUID.",
                                              'inArgs': [],
                                              'inverse': ('setUuid', False),
                                              'outArgs': [],
                                              'returnInfo': {'doc': "The node's UUID.",
                                                             'qualifiers': [],
                                                             'type': 'MUuid'},
                                              'returnType': 'MUuid',
                                              'static': False,
                                              'typeQualifiers': {},
                                              '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': {'affectsAnimation': 'getAffectsAnimation',
                                         'icon': 'getIcon',
                                         'name': 'getName',
                                         'uuid': 'getUuid'}},
  'MFnDirectionManip': {'enums': {},
                        'methods': {'className': [{'argInfo': {},
                                                   'args': [],
                                                   'defaults': {},
                                                   'deprecated': False,
                                                   'doc': 'Returns the name of this class.',
                                                   'inArgs': [],
                                                   'outArgs': [],
                                                   'returnInfo': {'doc': 'Name of this class.',
                                                                  'qualifiers': ['*'],
                                                                  'type': 'char'},
                                                   'returnType': 'char',
                                                   'static': True,
                                                   'typeQualifiers': {},
                                                   'types': {}}],
                                    'connectToDirectionPlug': [{'argInfo': {'directionPlug': {'doc': 'the direction plug',
                                                                                              'type': 'MPlug'}},
                                                                'args': [('directionPlug',
                                                                          'MPlug',
                                                                          'in')],
                                                                'defaults': {},
                                                                'deprecated': False,
                                                                'doc': 'Connect 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': "Creates 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': {},
                                                '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': "Creates 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': {'directionName': ['const',
                                                                                     '&'],
                                                                   'manipName': ['const',
                                                                                 '&']},
                                                'types': {'directionName': 'MString',
                                                          'manipName': 'MString'}}],
                                    'directionIndex': [{'argInfo': {},
                                                        'args': [],
                                                        'defaults': {},
                                                        'deprecated': False,
                                                        'doc': 'Returns the index of the direction. The data type corresponding to this index is MFnNumericData::k3Double.',
                                                        'inArgs': [],
                                                        'outArgs': [],
                                                        'returnInfo': {'doc': 'Direction index',
                                                                       'qualifiers': [],
                                                                       'type': 'uint'},
                                                        'returnType': 'uint',
                                                        'static': False,
                                                        'typeQualifiers': {},
                                                        'types': {}}],
                                    'endPointIndex': [{'argInfo': {},
                                                       'args': [],
                                                       'defaults': {},
                                                       'deprecated': False,
                                                       'doc': 'Returns 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': 'uint'},
                                                       'returnType': 'uint',
                                                       'static': False,
                                                       'typeQualifiers': {},
                                                       'types': {}}],
                                    'setDirection': [{'argInfo': {'direction': {'doc': 'the direction of the DirectionManip',
                                                                                'type': 'MVector'}},
                                                      'args': [('direction',
                                                                'MVector',
                                                                'in')],
                                                      'defaults': {},
                                                      'deprecated': False,
                                                      'doc': 'Sets 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': 'Sets 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': {},
                                                      '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': 'Sets 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': {},
                                                               'types': {'state': 'bool'}}],
                                    'setStartPoint': [{'argInfo': {'startPoint': {'doc': 'the start point of the DirectionManip',
                                                                                  'type': 'MPoint'}},
                                                       'args': [('startPoint',
                                                                 'MPoint',
                                                                 'in')],
                                                       'defaults': {},
                                                       'deprecated': False,
                                                       'doc': 'Sets 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': 'Returns 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': 'uint'},
                                                         'returnType': 'uint',
                                                         'static': False,
                                                         'typeQualifiers': {},
                                                         'types': {}}],
                                    'type': [{'argInfo': {},
                                              'args': [],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': 'Function set type',
                                              'inArgs': [],
                                              'outArgs': [],
                                              'returnInfo': {'doc': 'the class type.',
                                                             'qualifiers': [],
                                                             'type': ('MFn',
                                                                      'Type')},
                                              'returnType': ('MFn', 'Type'),
                                              'static': False,
                                              'typeQualifiers': {},
                                              'types': {}}]},
                        'pymelEnums': {}},
  'MFnDirectionalLight': {'enums': {},
                          'invertibles': [('setShadowAngle', 'shadowAngle'),
                                          ('setUseLightPosition',
                                           'useLightPosition')],
                          'methods': {'className': [{'argInfo': {},
                                                     'args': [],
                                                     'defaults': {},
                                                     'deprecated': False,
                                                     'doc': 'Returns the name of this class.',
                                                     'inArgs': [],
                                                     'outArgs': [],
                                                     'returnInfo': {'doc': 'Name of this class.',
                                                                    'qualifiers': ['*'],
                                                                    'type': 'char'},
                                                     'returnType': 'char',
                                                     'static': True,
                                                     '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': 'Creates 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': {},
                                                  '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': 'Creates 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': {'parent': ['const',
                                                                                '&']},
                                                  'types': {'UIvisible': 'bool',
                                                            'parent': 'MObject',
                                                            'wantTransform': 'bool'}}],
                                      'setShadowAngle': [{'argInfo': {'shadow_angle': {'doc': 'value to which the attribute will be set.',
                                                                                       'type': 'float'}},
                                                          'args': [('shadow_angle',
                                                                    'float',
                                                                    'in')],
                                                          'defaults': {},
                                                          'deprecated': False,
                                                          'doc': 'Sets 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': 'Sets 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': 'Retrieves 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': {},
                                                       'types': {}}],
                                      'type': [{'argInfo': {},
                                                'args': [],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': 'Function set type',
                                                'inArgs': [],
                                                'outArgs': [],
                                                'returnInfo': {'doc': 'the class type.',
                                                               'qualifiers': [],
                                                               'type': ('MFn',
                                                                        'Type')},
                                                'returnType': ('MFn', 'Type'),
                                                'static': False,
                                                'typeQualifiers': {},
                                                'types': {}}],
                                      'useLightPosition': [{'argInfo': {},
                                                            'args': [],
                                                            'defaults': {},
                                                            'deprecated': False,
                                                            'doc': 'Retrieves 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': {},
                                                            'types': {}}]},
                          'pymelEnums': {},
                          'pymelMethods': {'shadowAngle': 'getShadowAngle',
                                           'useLightPosition': 'getUseLightPosition'}},
  'MFnDiscManip': {'enums': {},
                   'methods': {'angleIndex': [{'argInfo': {},
                                               'args': [],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': 'Returns the index of the angle. The data type corresponding to this index is a double.',
                                               'inArgs': [],
                                               'outArgs': [],
                                               'returnInfo': {'doc': 'Angle index',
                                                              'qualifiers': [],
                                                              'type': 'uint'},
                                               'returnType': 'uint',
                                               'static': False,
                                               'typeQualifiers': {},
                                               'types': {}}],
                               'axisIndex': [{'argInfo': {},
                                              'args': [],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': 'Returns 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': 'uint'},
                                              'returnType': 'uint',
                                              'static': False,
                                              'typeQualifiers': {},
                                              'types': {}}],
                               'centerIndex': [{'argInfo': {},
                                                'args': [],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': 'Returns 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': 'uint'},
                                                'returnType': 'uint',
                                                'static': False,
                                                'typeQualifiers': {},
                                                'types': {}}],
                               'className': [{'argInfo': {},
                                              'args': [],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': 'Returns the name of this class.',
                                              'inArgs': [],
                                              'outArgs': [],
                                              'returnInfo': {'doc': 'Name of this class.',
                                                             'qualifiers': ['*'],
                                                             'type': 'char'},
                                              'returnType': 'char',
                                              'static': True,
                                              'typeQualifiers': {},
                                              'types': {}}],
                               'connectToAnglePlug': [{'argInfo': {'anglePlug': {'doc': 'the angle plug',
                                                                                 'type': 'MPlug'}},
                                                       'args': [('anglePlug',
                                                                 'MPlug',
                                                                 'in')],
                                                       'defaults': {},
                                                       'deprecated': False,
                                                       'doc': 'Connect 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': "Creates 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': {},
                                           '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': "Creates 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': {'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': 'Sets the angle of the DiscManip.',
                                             'inArgs': ['angle'],
                                             'outArgs': [],
                                             'returnInfo': {'doc': '',
                                                            'qualifiers': [],
                                                            'type': None},
                                             'returnType': None,
                                             'static': False,
                                             'typeQualifiers': {},
                                             'types': {'angle': 'MAngle'}}],
                               'setCenterPoint': [{'argInfo': {'centerPoint': {'doc': 'the center point of the DiscManip',
                                                                               'type': 'MPoint'}},
                                                   'args': [('centerPoint',
                                                             'MPoint',
                                                             'in')],
                                                   'defaults': {},
                                                   'deprecated': False,
                                                   'doc': 'Sets 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': 'Sets 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': 'Sets the radius of the DiscManip.',
                                              'inArgs': ['radius'],
                                              'outArgs': [],
                                              'returnInfo': {'doc': '',
                                                             'qualifiers': [],
                                                             'type': None},
                                              'returnType': None,
                                              'static': False,
                                              'typeQualifiers': {},
                                              'types': {'radius': 'double'}}],
                               'type': [{'argInfo': {},
                                         'args': [],
                                         'defaults': {},
                                         'deprecated': False,
                                         'doc': 'Function set type',
                                         'inArgs': [],
                                         'outArgs': [],
                                         'returnInfo': {'doc': 'the class type.',
                                                        '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': 'Returns the name of this class.',
                                                  'inArgs': [],
                                                  'outArgs': [],
                                                  'returnInfo': {'doc': 'Name of this class.',
                                                                 'qualifiers': ['*'],
                                                                 'type': 'char'},
                                                  'returnType': 'char',
                                                  'static': True,
                                                  'typeQualifiers': {},
                                                  'types': {}}],
                                   'connectToDistancePlug': [{'argInfo': {'distancePlug': {'doc': 'the distance plug',
                                                                                           'type': 'MPlug'}},
                                                              'args': [('distancePlug',
                                                                        'MPlug',
                                                                        'in')],
                                                              'defaults': {},
                                                              'deprecated': False,
                                                              'doc': 'Connect 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': "Creates 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': {},
                                               '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': "Creates 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': {'distanceName': ['const',
                                                                                   '&'],
                                                                  'manipName': ['const',
                                                                                '&']},
                                               'types': {'distanceName': 'MString',
                                                         'manipName': 'MString'}}],
                                   'currentPointIndex': [{'argInfo': {},
                                                          'args': [],
                                                          'defaults': {},
                                                          'deprecated': False,
                                                          'doc': 'Returns 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': 'uint'},
                                                          'returnType': 'uint',
                                                          'static': False,
                                                          'typeQualifiers': {},
                                                          'types': {}}],
                                   'directionIndex': [{'argInfo': {},
                                                       'args': [],
                                                       'defaults': {},
                                                       'deprecated': False,
                                                       'doc': 'Returns the index of the direction. The data type corresponding to this index is MFnNumericData::k3Double.',
                                                       'inArgs': [],
                                                       'outArgs': [],
                                                       'returnInfo': {'doc': 'Direction index',
                                                                      'qualifiers': [],
                                                                      'type': 'uint'},
                                                       'returnType': 'uint',
                                                       'static': False,
                                                       'typeQualifiers': {},
                                                       'types': {}}],
                                   'distanceIndex': [{'argInfo': {},
                                                      'args': [],
                                                      'defaults': {},
                                                      'deprecated': False,
                                                      'doc': 'Returns the index of the distance. The data type corresponding to this index is a double.',
                                                      'inArgs': [],
                                                      'outArgs': [],
                                                      'returnInfo': {'doc': 'Distance index',
                                                                     'qualifiers': [],
                                                                     'type': 'uint'},
                                                      'returnType': 'uint',
                                                      'static': False,
                                                      'typeQualifiers': {},
                                                      'types': {}}],
                                   'isDrawLineOn': [{'argInfo': {},
                                                     'args': [],
                                                     'defaults': {},
                                                     'deprecated': False,
                                                     'doc': 'Returns 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': {},
                                                     'types': {}}],
                                   'isDrawStartOn': [{'argInfo': {},
                                                      'args': [],
                                                      'defaults': {},
                                                      'deprecated': False,
                                                      'doc': 'Returns 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': {},
                                                      'types': {}}],
                                   'scalingFactor': [{'argInfo': {},
                                                      'args': [],
                                                      'defaults': {},
                                                      'deprecated': False,
                                                      'doc': 'Returns 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': {},
                                                      'types': {}}],
                                   'setDirection': [{'argInfo': {'direction': {'doc': 'the direction of the DistanceManip',
                                                                               'type': 'MVector'}},
                                                     'args': [('direction',
                                                               'MVector',
                                                               'in')],
                                                     'defaults': {},
                                                     'deprecated': False,
                                                     'doc': 'Sets 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': 'Sets 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': {},
                                                    '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': 'Sets 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': {},
                                                     'types': {'state': 'bool'}}],
                                   'setScalingFactor': [{'argInfo': {'scalingFactor': {'doc': 'the scaling factor',
                                                                                       'type': 'double'}},
                                                         'args': [('scalingFactor',
                                                                   'double',
                                                                   'in')],
                                                         'defaults': {},
                                                         'deprecated': False,
                                                         'doc': 'Sets 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': {},
                                                         'types': {'scalingFactor': 'double'}}],
                                   'setStartPoint': [{'argInfo': {'startPoint': {'doc': 'the start point of the DistanceManip',
                                                                                 'type': 'MPoint'}},
                                                      'args': [('startPoint',
                                                                'MPoint',
                                                                'in')],
                                                      'defaults': {},
                                                      'deprecated': False,
                                                      'doc': 'Sets 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': 'Returns 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': 'uint'},
                                                        'returnType': 'uint',
                                                        'static': False,
                                                        'typeQualifiers': {},
                                                        'types': {}}],
                                   'type': [{'argInfo': {},
                                             'args': [],
                                             'defaults': {},
                                             'deprecated': False,
                                             'doc': 'Function set type',
                                             'inArgs': [],
                                             'outArgs': [],
                                             'returnInfo': {'doc': 'the class type.',
                                                            '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': 'Extract 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'}}],
                                     'array': [{'argInfo': {},
                                                'args': [],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': 'Return 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': {},
                                                'types': {}}],
                                     'className': [{'argInfo': {},
                                                    'args': [],
                                                    'defaults': {},
                                                    'deprecated': False,
                                                    'doc': 'Returns the name of this class.',
                                                    'inArgs': [],
                                                    'outArgs': [],
                                                    'returnInfo': {'doc': 'Name of this class.',
                                                                   'qualifiers': ['*'],
                                                                   'type': 'char'},
                                                    'returnType': 'char',
                                                    'static': True,
                                                    'typeQualifiers': {},
                                                    'types': {}}],
                                     'copyTo': [{'argInfo': {'dest': {'doc': 'the MDoubleArray to populate',
                                                                      'type': 'MDoubleArray'}},
                                                 'args': [('dest',
                                                           'MDoubleArray',
                                                           'out')],
                                                 'defaults': {},
                                                 'deprecated': False,
                                                 'doc': 'Copy 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': 'Create 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': {},
                                                 'types': {}},
                                                {'argInfo': {'arr': {'doc': 'the data to use when initializing this instance',
                                                                     'type': 'MDoubleArray'}},
                                                 'args': [('arr',
                                                           'MDoubleArray',
                                                           'in')],
                                                 'defaults': {},
                                                 'deprecated': False,
                                                 'doc': 'Create 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': {'arr': ['const',
                                                                            '&']},
                                                 'types': {'arr': 'MDoubleArray'}}],
                                     'length': [{'argInfo': {},
                                                 'args': [],
                                                 'defaults': {},
                                                 'deprecated': False,
                                                 'doc': 'Return the number of doubles in the instance.',
                                                 'inArgs': [],
                                                 'outArgs': [],
                                                 'returnInfo': {'doc': 'The number of doubles in the instance',
                                                                'qualifiers': [],
                                                                'type': 'uint'},
                                                 'returnType': 'uint',
                                                 'static': False,
                                                 'typeQualifiers': {},
                                                 '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': 'Set 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': {'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': 'Set 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': 'Function set type',
                                               'inArgs': [],
                                               'outArgs': [],
                                               'returnInfo': {'doc': 'the class type.',
                                                              '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': 'Add the specified element to the component.',
                                                            'inArgs': ['uIndex',
                                                                       'vIndex'],
                                                            'outArgs': [],
                                                            'returnInfo': {'doc': '',
                                                                           'qualifiers': [],
                                                                           'type': None},
                                                            'returnType': None,
                                                            'static': False,
                                                            'typeQualifiers': {},
                                                            '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': 'Add 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': 'Returns the name of this class.',
                                                           'inArgs': [],
                                                           'outArgs': [],
                                                           'returnInfo': {'doc': 'Name of this class.',
                                                                          'qualifiers': ['*'],
                                                                          'type': 'char'},
                                                           'returnType': 'char',
                                                           'static': True,
                                                           'typeQualifiers': {},
                                                           'types': {}}],
                                            'create': [{'argInfo': {'compType': {'doc': 'the type of component to create',
                                                                                 'type': ('MFn',
                                                                                          'Type')}},
                                                        'args': [('compType',
                                                                  ('MFn',
                                                                   'Type'),
                                                                  'in')],
                                                        'defaults': {},
                                                        'deprecated': False,
                                                        'doc': 'Create 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': {},
                                                        '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': 'Returns 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': 'Get the specified element from the component.',
                                                            'inArgs': ['index'],
                                                            'outArgs': ['uIndex',
                                                                        'vIndex'],
                                                            'returnInfo': {'doc': '',
                                                                           'qualifiers': [],
                                                                           'type': None},
                                                            'returnType': None,
                                                            'static': False,
                                                            'typeQualifiers': {'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': 'Get 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': 'Marks 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': {},
                                                                 'types': {'maxU': 'int',
                                                                           'maxV': 'int'}}],
                                            'type': [{'argInfo': {},
                                                      'args': [],
                                                      'defaults': {},
                                                      'deprecated': False,
                                                      'doc': 'Function set type',
                                                      'inArgs': [],
                                                      'outArgs': [],
                                                      'returnInfo': {'doc': 'the class type.',
                                                                     'qualifiers': [],
                                                                     'type': ('MFn',
                                                                              'Type')},
                                                      'returnType': ('MFn',
                                                                     'Type'),
                                                      'static': False,
                                                      'typeQualifiers': {},
                                                      'types': {}}]},
                                'pymelEnums': {}},
  'MFnDragField': {'enums': {},
                   'invertibles': [('setDirection', 'direction'),
                                   ('setUseDirection', 'useDirection')],
                   'methods': {'className': [{'argInfo': {},
                                              'args': [],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': 'Returns the name of this class.',
                                              'inArgs': [],
                                              'outArgs': [],
                                              'returnInfo': {'doc': 'Name of this class.',
                                                             'qualifiers': ['*'],
                                                             'type': 'char'},
                                              'returnType': 'char',
                                              'static': True,
                                              'typeQualifiers': {},
                                              'types': {}}],
                               'direction': [{'argInfo': {},
                                              'args': [],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': "Returns 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': {},
                                              'types': {}}],
                               'setDirection': [{'argInfo': {'dragDirection': {'doc': 'A vector representing direction.',
                                                                               'type': 'MVector'}},
                                                 'args': [('dragDirection',
                                                           'MVector',
                                                           'in')],
                                                 'defaults': {},
                                                 'deprecated': False,
                                                 'doc': "Sets 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': "Enables 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': {},
                                                    'types': {'enable': 'bool'}}],
                               'type': [{'argInfo': {},
                                         'args': [],
                                         'defaults': {},
                                         'deprecated': False,
                                         'doc': 'Function set type',
                                         'inArgs': [],
                                         'outArgs': [],
                                         'returnInfo': {'doc': 'the class type.',
                                                        'qualifiers': [],
                                                        'type': ('MFn',
                                                                 'Type')},
                                         'returnType': ('MFn', 'Type'),
                                         'static': False,
                                         'typeQualifiers': {},
                                         'types': {}}],
                               'useDirection': [{'argInfo': {},
                                                 'args': [],
                                                 'defaults': {},
                                                 'deprecated': False,
                                                 'doc': "Returns 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': {},
                                                 'types': {}}]},
                   'pymelEnums': {},
                   'pymelMethods': {'direction': 'getDirection',
                                    'useDirection': 'getUseDirection'}},
  'MFnDynSweptGeometryData': {'enums': {},
                              'methods': {'className': [{'argInfo': {},
                                                         'args': [],
                                                         'defaults': {},
                                                         'deprecated': False,
                                                         'doc': 'Returns the name of this class.',
                                                         'inArgs': [],
                                                         'outArgs': [],
                                                         'returnInfo': {'doc': 'Name of this class.',
                                                                        'qualifiers': ['*'],
                                                                        'type': 'char'},
                                                         'returnType': 'char',
                                                         'static': True,
                                                         'typeQualifiers': {},
                                                         'types': {}}],
                                          'create': [{'argInfo': {},
                                                      'args': [],
                                                      'defaults': {},
                                                      'deprecated': False,
                                                      'doc': 'This 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': {},
                                                      'types': {}}],
                                          'lineCount': [{'argInfo': {},
                                                         'args': [],
                                                         'defaults': {},
                                                         'deprecated': False,
                                                         'doc': 'Return 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': {},
                                                         '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': 'Return data for a swept line.',
                                                         'inArgs': ['index'],
                                                         'outArgs': [],
                                                         'returnInfo': {'doc': 'A const reference to the MDynSweptLine',
                                                                        'qualifiers': [],
                                                                        'type': 'MDynSweptLine'},
                                                         'returnType': 'MDynSweptLine',
                                                         'static': False,
                                                         'typeQualifiers': {},
                                                         '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': 'Return data for a swept triangle.',
                                                             'inArgs': ['index'],
                                                             'outArgs': [],
                                                             'returnInfo': {'doc': 'A const reference to the MDynSweptTriangle',
                                                                            'qualifiers': [],
                                                                            'type': 'MDynSweptTriangle'},
                                                             'returnType': 'MDynSweptTriangle',
                                                             'static': False,
                                                             'typeQualifiers': {},
                                                             'types': {'index': 'int'}}],
                                          'triangleCount': [{'argInfo': {},
                                                             'args': [],
                                                             'defaults': {},
                                                             'deprecated': False,
                                                             'doc': 'Return the number of triangles contained in the data.',
                                                             'inArgs': [],
                                                             'outArgs': [],
                                                             'returnInfo': {'doc': 'Number of triangles',
                                                                            'qualifiers': [],
                                                                            'type': 'int'},
                                                             'returnType': 'int',
                                                             'static': False,
                                                             'typeQualifiers': {},
                                                             'types': {}}],
                                          'type': [{'argInfo': {},
                                                    'args': [],
                                                    'defaults': {},
                                                    'deprecated': False,
                                                    'doc': 'Function set type',
                                                    'inArgs': [],
                                                    'outArgs': [],
                                                    'returnInfo': {'doc': 'the class type.',
                                                                   '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': 'Add 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',
                                                                                    '&']},
                                                 'types': {'fieldString': 'MString',
                                                           'index': 'short'}}],
                                   'className': [{'argInfo': {},
                                                  'args': [],
                                                  'defaults': {},
                                                  'deprecated': False,
                                                  'doc': 'Returns the name of this class.',
                                                  'inArgs': [],
                                                  'outArgs': [],
                                                  'returnInfo': {'doc': 'Name of this class.',
                                                                 'qualifiers': ['*'],
                                                                 'type': 'char'},
                                                  'returnType': 'char',
                                                  'static': True,
                                                  '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': 'Creates 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': {'briefName': ['const',
                                                                                '&'],
                                                                  'fullName': ['const',
                                                                               '&']},
                                               'types': {'briefName': 'MString',
                                                         'defaultValue': 'short',
                                                         'fullName': 'MString'}}],
                                   'defaultValue': [{'argInfo': {},
                                                     'args': [],
                                                     'defaults': {},
                                                     'deprecated': False,
                                                     'doc': 'Get 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': {},
                                                     'types': {}}],
                                   'fieldIndex': [{'argInfo': {'fieldString': {'doc': 'The string describing the field.',
                                                                               'type': 'MString'}},
                                                   'args': [('fieldString',
                                                             'MString',
                                                             'in')],
                                                   'defaults': {},
                                                   'deprecated': False,
                                                   'doc': 'Retrieve 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': {'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': 'Retrieve 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': {},
                                                  'types': {'index': 'short'}}],
                                   'getDefault': [{'argInfo': {'index': {'doc': 'default index value.',
                                                                         'type': 'short'}},
                                                   'args': [('index',
                                                             'short',
                                                             'out')],
                                                   'defaults': {},
                                                   'deprecated': False,
                                                   'doc': 'Get 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'}}],
                                   'getMax': [{'argInfo': {'maxValue': {'doc': 'the maximum value for this attribute',
                                                                        'type': 'short'}},
                                               'args': [('maxValue',
                                                         'short',
                                                         'out')],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': 'Return 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': 'Return 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': 'Set a new default value for this enum attribute.',
                                                   'inArgs': ['index'],
                                                   'inverse': ('getDefault',
                                                               True),
                                                   'outArgs': [],
                                                   'returnInfo': {'doc': '',
                                                                  'qualifiers': [],
                                                                  'type': None},
                                                   'returnType': None,
                                                   'static': False,
                                                   'typeQualifiers': {},
                                                   'types': {'index': 'short'}},
                                                  {'argInfo': {'fieldString': {'doc': 'new the default value for this attribute',
                                                                               'type': 'MString'}},
                                                   'args': [('fieldString',
                                                             'MString',
                                                             'in')],
                                                   'defaults': {},
                                                   'deprecated': False,
                                                   'doc': 'Set 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': 'Function set type',
                                             'inArgs': [],
                                             'outArgs': [],
                                             'returnInfo': {'doc': 'the class type.',
                                                            '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': [('setAnimated', 'isAnimated'),
                                    ('setDefaultObject', 'getDefaultObject'),
                                    ('setExpression', 'expression'),
                                    ('setUnitConversion', 'unitConversion')],
                    'methods': {'className': [{'argInfo': {},
                                               'args': [],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': 'Returns the name of this class.',
                                               'inArgs': [],
                                               'outArgs': [],
                                               'returnInfo': {'doc': 'Name of this class.',
                                                              'qualifiers': ['*'],
                                                              'type': 'char'},
                                               'returnType': 'char',
                                               'static': True,
                                               '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': 'This 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': {'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': 'Evaluate 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': 'Gets 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': {},
                                                'types': {}}],
                                'getDefaultObject': [{'argInfo': {'object': {'doc': 'storage for the default object',
                                                                             'type': 'MObject'}},
                                                      'args': [('object',
                                                                'MObject',
                                                                'out')],
                                                      'defaults': {},
                                                      'deprecated': False,
                                                      'doc': 'Gets 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'}}],
                                'isAnimated': [{'argInfo': {},
                                                'args': [],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': 'If 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': {},
                                                'types': {}}],
                                'setAnimated': [{'argInfo': {'value': {'doc': 'sets the objects evaluation type',
                                                                       'type': 'bool'}},
                                                 'args': [('value',
                                                           'bool',
                                                           'in')],
                                                 'defaults': {'value': False},
                                                 'deprecated': False,
                                                 'doc': 'Sets the way in which the expression is evaluated.',
                                                 'inArgs': ['value'],
                                                 'inverse': ('isAnimated',
                                                             True),
                                                 'outArgs': [],
                                                 'returnInfo': {'doc': '',
                                                                'qualifiers': [],
                                                                'type': None},
                                                 'returnType': None,
                                                 'static': False,
                                                 'typeQualifiers': {},
                                                 'types': {'value': 'bool'}}],
                                'setDefaultObject': [{'argInfo': {'object': {'doc': 'the object to be set',
                                                                             'type': 'MObject'}},
                                                      'args': [('object',
                                                                'MObject',
                                                                'in')],
                                                      'defaults': {},
                                                      'deprecated': False,
                                                      'doc': 'Sets 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': 'Sets 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': 'Set the unit conversion options for the expression node.',
                                                       'inArgs': ['conversion'],
                                                       'inverse': ('unitConversion',
                                                                   True),
                                                       'outArgs': [],
                                                       'returnInfo': {'doc': '',
                                                                      'qualifiers': [],
                                                                      'type': None},
                                                       'returnType': None,
                                                       'static': False,
                                                       'typeQualifiers': {},
                                                       'types': {'conversion': ('MFnExpression',
                                                                                'UnitConversion')}}],
                                'type': [{'argInfo': {},
                                          'args': [],
                                          'defaults': {},
                                          'deprecated': False,
                                          'doc': 'Function set type',
                                          'inArgs': [],
                                          'outArgs': [],
                                          'returnInfo': {'doc': 'the class type.',
                                                         'qualifiers': [],
                                                         'type': ('MFn',
                                                                  'Type')},
                                          'returnType': ('MFn', 'Type'),
                                          'static': False,
                                          'typeQualifiers': {},
                                          'types': {}}],
                                'unitConversion': [{'argInfo': {},
                                                    'args': [],
                                                    'defaults': {},
                                                    'deprecated': False,
                                                    'doc': 'Get 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': {},
                                                    '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'),
                               ('setMagnitude', 'magnitude'),
                               ('setMaxDistance', 'maxDistance'),
                               ('setPerVertex', 'perVertex'),
                               ('setUseMaxDistance', 'useMaxDistance')],
               'methods': {'attenuation': [{'argInfo': {},
                                            'args': [],
                                            'defaults': {},
                                            'deprecated': False,
                                            'doc': 'Returns 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': {},
                                            'types': {}}],
                           'className': [{'argInfo': {},
                                          'args': [],
                                          'defaults': {},
                                          'deprecated': False,
                                          'doc': 'Returns the name of this class.',
                                          'inArgs': [],
                                          'outArgs': [],
                                          'returnInfo': {'doc': 'Name of this class.',
                                                         'qualifiers': ['*'],
                                                         'type': 'char'},
                                          'returnType': 'char',
                                          'static': True,
                                          'typeQualifiers': {},
                                          'types': {}}],
                           'falloffCurve': [{'argInfo': {'param': {'doc': 'Parameter',
                                                                   'type': 'double'}},
                                             'args': [('param',
                                                       'double',
                                                       'in')],
                                             'defaults': {},
                                             'deprecated': False,
                                             'doc': 'Returns 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': {'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': 'Compute 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': {'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': 'Compute 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': {'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': 'Returns 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': {},
                                                          'types': {}}],
                           'magnitude': [{'argInfo': {},
                                          'args': [],
                                          'defaults': {},
                                          'deprecated': False,
                                          'doc': 'Returns 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': {},
                                          'types': {}}],
                           'maxDistance': [{'argInfo': {},
                                            'args': [],
                                            'defaults': {},
                                            'deprecated': False,
                                            'doc': "Returns 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': 'linear'},
                                            'returnType': 'double',
                                            'static': False,
                                            'typeQualifiers': {},
                                            'types': {}}],
                           'perVertex': [{'argInfo': {},
                                          'args': [],
                                          'defaults': {},
                                          'deprecated': False,
                                          'doc': 'Returns 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': {},
                                          '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': 'Sets 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': {},
                                               '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': 'Sets the strength of the field.',
                                             'inArgs': ['mag'],
                                             'inverse': ('magnitude', True),
                                             'outArgs': [],
                                             'returnInfo': {'doc': '',
                                                            'qualifiers': [],
                                                            'type': None},
                                             'returnType': None,
                                             'static': False,
                                             'typeQualifiers': {},
                                             'types': {'mag': 'double'}}],
                           'setMaxDistance': [{'argInfo': {'dist': {'doc': 'A value representing distance in internal linear units.',
                                                                    'type': 'double',
                                                                    'unitType': 'linear'}},
                                               'args': [('dist',
                                                         'double',
                                                         'in')],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': 'Sets 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': {},
                                               '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': 'Enables 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': {},
                                             'types': {'enable': 'bool'}}],
                           'setUseMaxDistance': [{'argInfo': {'enable': {'doc': 'Flag to enable or disable maximum distance.',
                                                                         'type': 'bool'}},
                                                  'args': [('enable',
                                                            'bool',
                                                            'in')],
                                                  'defaults': {},
                                                  'deprecated': False,
                                                  'doc': 'Enables 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': {},
                                                  'types': {'enable': 'bool'}}],
                           'type': [{'argInfo': {},
                                     'args': [],
                                     'defaults': {},
                                     'deprecated': False,
                                     'doc': 'Function set type',
                                     'inArgs': [],
                                     'outArgs': [],
                                     'returnInfo': {'doc': 'the class type.',
                                                    'qualifiers': [],
                                                    'type': ('MFn', 'Type')},
                                     'returnType': ('MFn', 'Type'),
                                     'static': False,
                                     'typeQualifiers': {},
                                     'types': {}}],
                           'useMaxDistance': [{'argInfo': {},
                                               'args': [],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': 'Returns 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': {},
                                               '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': 'Extract 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'}}],
                                    'array': [{'argInfo': {},
                                               'args': [],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': 'Return 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': {},
                                               'types': {}}],
                                    'className': [{'argInfo': {},
                                                   'args': [],
                                                   'defaults': {},
                                                   'deprecated': False,
                                                   'doc': 'Returns the name of this class.',
                                                   'inArgs': [],
                                                   'outArgs': [],
                                                   'returnInfo': {'doc': 'Name of this class.',
                                                                  'qualifiers': ['*'],
                                                                  'type': 'char'},
                                                   'returnType': 'char',
                                                   'static': True,
                                                   'typeQualifiers': {},
                                                   'types': {}}],
                                    'copyTo': [{'argInfo': {'dest': {'doc': 'the MFloatArray to populate',
                                                                     'type': 'MFloatArray'}},
                                                'args': [('dest',
                                                          'MFloatArray',
                                                          'out')],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': 'Copy 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': 'Create 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': {},
                                                'types': {}},
                                               {'argInfo': {'arr': {'doc': 'the data to use when initializing this instance',
                                                                    'type': 'MFloatArray'}},
                                                'args': [('arr',
                                                          'MFloatArray',
                                                          'in')],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': 'Create 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': {'arr': ['const',
                                                                           '&']},
                                                'types': {'arr': 'MFloatArray'}}],
                                    'length': [{'argInfo': {},
                                                'args': [],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': 'Return the number of floats in the instance.',
                                                'inArgs': [],
                                                'outArgs': [],
                                                'returnInfo': {'doc': 'The number of floats in the instance',
                                                               'qualifiers': [],
                                                               'type': 'uint'},
                                                'returnType': 'uint',
                                                'static': False,
                                                'typeQualifiers': {},
                                                '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': 'Set 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': {'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': 'Set 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': 'Function set type',
                                              'inArgs': [],
                                              'outArgs': [],
                                              'returnInfo': {'doc': 'the class type.',
                                                             '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': [('setColorMode', 'getColorMode'),
                               ('setCoordinateMode', 'getCoordinateMode'),
                               ('setDensityMode', 'getDensityMode'),
                               ('setFalloffMode', 'getFalloffMode'),
                               ('setFuelMode', 'getFuelMode'),
                               ('setTemperatureMode', 'getTemperatureMode'),
                               ('setVelocityMode', 'getVelocityMode')],
               'methods': {'className': [{'argInfo': {},
                                          'args': [],
                                          'defaults': {},
                                          'deprecated': False,
                                          'doc': 'Returns the name of this class.',
                                          'inArgs': [],
                                          'outArgs': [],
                                          'returnInfo': {'doc': 'Name of this class.',
                                                         'qualifiers': ['*'],
                                                         'type': 'char'},
                                          'returnType': 'char',
                                          'static': True,
                                          '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': 'Creates 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': {'Xres': ['unsigned'],
                                                            'Yres': ['unsigned']},
                                         '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': 'Creates 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': {'Xres': ['unsigned'],
                                                            'Yres': ['unsigned'],
                                                            'Zres': ['unsigned']},
                                         'types': {'Xdim': 'double',
                                                   'Xres': 'uint',
                                                   'Ydim': 'double',
                                                   'Yres': 'uint',
                                                   'Zdim': 'double',
                                                   'Zres': 'uint',
                                                   'parent': 'MObject'}}],
                           'density': [{'argInfo': {},
                                        'args': [],
                                        'defaults': {},
                                        'deprecated': False,
                                        'doc': 'This 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': {},
                                        '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': 'Use 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': {'emitColor': ['const',
                                                                                '&']},
                                               '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': 'Tells 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': 'This 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': {},
                                        'types': {}}],
                           'fuel': [{'argInfo': {},
                                     'args': [],
                                     'defaults': {},
                                     'deprecated': False,
                                     'doc': 'This 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': {},
                                     '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': 'Get 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': 'This 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': 'Get 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': 'This 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': 'Get 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': 'Gets 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': 'Get 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': 'Compute 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': {'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': 'Compute 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': {'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': 'Get 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': 'Gets 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': 'Gets 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': 'Get 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': 'This 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': 'Get 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': 'Returns 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': 'uint'},
                                         'returnType': 'uint',
                                         'static': False,
                                         'typeQualifiers': {},
                                         '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': "This 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': {},
                                      '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': "This 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': {},
                                      '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': "This 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': {'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': 'This 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': {},
                                      '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': 'This 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': {'xi': ['&'],
                                                         'yi': ['&'],
                                                         'zi': ['&']},
                                      'types': {'index': 'int',
                                                'xi': 'int',
                                                'xres': 'int',
                                                'yi': 'int',
                                                'yres': 'int',
                                                'zi': 'int',
                                                'zres': 'int'}}],
                           'isAutoResize': [{'argInfo': {},
                                             'args': [],
                                             'defaults': {},
                                             'deprecated': False,
                                             'doc': 'Is this an autoresize fluid?',
                                             'inArgs': [],
                                             'outArgs': [],
                                             'returnInfo': {'doc': 'true if autoresize, false otherwise.',
                                                            'qualifiers': [],
                                                            'type': 'bool'},
                                             'returnType': 'bool',
                                             'static': False,
                                             'typeQualifiers': {},
                                             'types': {}}],
                           'isResizeToEmitter': [{'argInfo': {},
                                                  'args': [],
                                                  'defaults': {},
                                                  'deprecated': False,
                                                  'doc': 'If this is an autoresize fluid, should it also resize to the emitter',
                                                  'inArgs': [],
                                                  'outArgs': [],
                                                  'returnInfo': {'doc': 'true if autoresize and resizeToEmitter, false otherwise.',
                                                                 'qualifiers': [],
                                                                 'type': 'bool'},
                                                  'returnType': 'bool',
                                                  'static': False,
                                                  'typeQualifiers': {},
                                                  'types': {}}],
                           'pressure': [{'argInfo': {},
                                         'args': [],
                                         'defaults': {},
                                         'deprecated': False,
                                         'doc': 'This 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': {},
                                         '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': 'Set 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': {},
                                             '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': 'Set 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': {},
                                                  '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': 'Set 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': {},
                                               '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': 'Set 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': {},
                                               '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': 'Set 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': {},
                                            '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': 'Sets 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': {'Xres': ['unsigned'],
                                                           'Yres': ['unsigned'],
                                                           'Zres': ['unsigned']},
                                        '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': 'Sets 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': {'Xres': ['unsigned'],
                                                           'Yres': ['unsigned']},
                                        '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': 'Set 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': {},
                                                   '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': 'Set 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': {},
                                                'types': {'gradient': ('MFnFluid',
                                                                       'FluidGradient'),
                                                          'method': ('MFnFluid',
                                                                     'FluidMethod')}}],
                           'temperature': [{'argInfo': {},
                                            'args': [],
                                            'defaults': {},
                                            'deprecated': False,
                                            'doc': 'This 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': {},
                                            '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': 'For 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',
                                                                                    '&']},
                                            'types': {'gridCoords': 'int3',
                                                      'objectSpacePoint': 'MPoint'}}],
                           'type': [{'argInfo': {},
                                     'args': [],
                                     'defaults': {},
                                     'deprecated': False,
                                     'doc': 'Function set type',
                                     'inArgs': [],
                                     'outArgs': [],
                                     'returnInfo': {'doc': 'the class type.',
                                                    'qualifiers': [],
                                                    'type': ('MFn', 'Type')},
                                     'returnType': ('MFn', 'Type'),
                                     'static': False,
                                     'typeQualifiers': {},
                                     'types': {}}],
                           'updateGrid': [{'argInfo': {},
                                           'args': [],
                                           'defaults': {},
                                           'deprecated': False,
                                           'doc': 'Tells 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': 'Returns 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': 'For 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': ['&']},
                                                    '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': 'Returns the name of this class.',
                                                        'inArgs': [],
                                                        'outArgs': [],
                                                        'returnInfo': {'doc': 'Name of this class.',
                                                                       'qualifiers': ['*'],
                                                                       'type': 'char'},
                                                        'returnType': 'char',
                                                        'static': True,
                                                        'typeQualifiers': {},
                                                        'types': {}}],
                                         'connectToPointPlug': [{'argInfo': {'pointPlug': {'doc': 'the point plug',
                                                                                           'type': 'MPlug'}},
                                                                 'args': [('pointPlug',
                                                                           'MPlug',
                                                                           'in')],
                                                                 'defaults': {},
                                                                 'deprecated': False,
                                                                 'doc': 'Connect 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': "Creates 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': {},
                                                     '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': "Creates 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': {'manipName': ['const',
                                                                                      '&'],
                                                                        'pointName': ['const',
                                                                                      '&']},
                                                     'types': {'manipName': 'MString',
                                                               'pointName': 'MString'}}],
                                         'isDrawAxesOn': [{'argInfo': {},
                                                           'args': [],
                                                           'defaults': {},
                                                           'deprecated': False,
                                                           'doc': 'Returns 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': {},
                                                           'types': {}}],
                                         'isKeyframeAllOn': [{'argInfo': {},
                                                              'args': [],
                                                              'defaults': {},
                                                              'deprecated': False,
                                                              'doc': 'Returns 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': {},
                                                              'types': {}}],
                                         'isSnapModeOn': [{'argInfo': {},
                                                           'args': [],
                                                           'defaults': {},
                                                           'deprecated': False,
                                                           'doc': 'Returns 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': {},
                                                           'types': {}}],
                                         'pointIndex': [{'argInfo': {},
                                                         'args': [],
                                                         'defaults': {},
                                                         'deprecated': False,
                                                         'doc': 'Returns 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': 'uint'},
                                                         'returnType': 'uint',
                                                         'static': False,
                                                         'typeQualifiers': {},
                                                         'types': {}}],
                                         'setDirection': [{'argInfo': {'direction': {'doc': 'the new direction for freePointTriadManip.',
                                                                                     'type': 'MVector'}},
                                                           'args': [('direction',
                                                                     'MVector',
                                                                     'in')],
                                                           'defaults': {},
                                                           'deprecated': False,
                                                           'doc': 'Sets 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': 'Sets whether or not drawArrowHead is on.',
                                                               'inArgs': ['state'],
                                                               'outArgs': [],
                                                               'returnInfo': {'doc': '',
                                                                              'qualifiers': [],
                                                                              'type': None},
                                                               'returnType': None,
                                                               'static': False,
                                                               'typeQualifiers': {},
                                                               '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': 'Sets 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': {},
                                                          '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': 'Sets 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': {},
                                                                  'types': {'whichPlane': ('MFnFreePointTriadManip',
                                                                                           'ManipPlane')}}],
                                         'setKeyframeAll': [{'argInfo': {'state': {'doc': 'whether or not keyframeAll is on',
                                                                                   'type': 'bool'}},
                                                             'args': [('state',
                                                                       'bool',
                                                                       'in')],
                                                             'defaults': {},
                                                             'deprecated': False,
                                                             'doc': 'Sets whether or not keyframeAll is on.',
                                                             'inArgs': ['state'],
                                                             'outArgs': [],
                                                             'returnInfo': {'doc': '',
                                                                            'qualifiers': [],
                                                                            'type': None},
                                                             'returnType': None,
                                                             'static': False,
                                                             'typeQualifiers': {},
                                                             'types': {'state': 'bool'}}],
                                         'setPoint': [{'argInfo': {'pointValue': {'doc': 'The new value of the point manipValue',
                                                                                  'type': 'MPoint'}},
                                                       'args': [('pointValue',
                                                                 'MPoint',
                                                                 'in')],
                                                       'defaults': {},
                                                       'deprecated': False,
                                                       'doc': 'Set 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': 'Sets whether or not to the FreePointTriadManip should be in snap mode.',
                                                          'inArgs': ['state'],
                                                          'outArgs': [],
                                                          'returnInfo': {'doc': '',
                                                                         'qualifiers': [],
                                                                         'type': None},
                                                          'returnType': None,
                                                          'static': False,
                                                          'typeQualifiers': {},
                                                          'types': {'state': 'bool'}}],
                                         'type': [{'argInfo': {},
                                                   'args': [],
                                                   'defaults': {},
                                                   'deprecated': False,
                                                   'doc': 'Function set type',
                                                   'inArgs': [],
                                                   'outArgs': [],
                                                   'returnInfo': {'doc': 'the class type.',
                                                                  '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': 'Add 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': 'Add a new connection type that this attribute can accept.',
                                                         'inArgs': ['newType'],
                                                         'outArgs': [],
                                                         'returnInfo': {'doc': '',
                                                                        'qualifiers': [],
                                                                        'type': None},
                                                         'returnType': None,
                                                         'static': False,
                                                         'typeQualifiers': {},
                                                         'types': {'newType': ('MFnData',
                                                                               'Type')}}],
                                      'addNumericDataAccept': [{'argInfo': {'newType': {'doc': 'new type',
                                                                                        'type': ('MFnNumericData',
                                                                                                 'Type')}},
                                                                'args': [('newType',
                                                                          ('MFnNumericData',
                                                                           'Type'),
                                                                          'in')],
                                                                'defaults': {},
                                                                'deprecated': False,
                                                                'doc': 'Add a new connection type that this attribute can accept.',
                                                                'inArgs': ['newType'],
                                                                'outArgs': [],
                                                                'returnInfo': {'doc': '',
                                                                               'qualifiers': [],
                                                                               'type': None},
                                                                'returnType': None,
                                                                'static': False,
                                                                'typeQualifiers': {},
                                                                'types': {'newType': ('MFnNumericData',
                                                                                      'Type')}}],
                                      'className': [{'argInfo': {},
                                                     'args': [],
                                                     'defaults': {},
                                                     'deprecated': False,
                                                     'doc': 'Returns the name of this class.',
                                                     'inArgs': [],
                                                     'outArgs': [],
                                                     'returnInfo': {'doc': 'Name of this class.',
                                                                    'qualifiers': ['*'],
                                                                    'type': 'char'},
                                                     'returnType': 'char',
                                                     'static': True,
                                                     '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': 'Creates a new generic attribute.',
                                                  'inArgs': ['full', 'brief'],
                                                  'outArgs': [],
                                                  'returnInfo': {'doc': 'New attribute.',
                                                                 'qualifiers': [],
                                                                 'type': 'MObject'},
                                                  'returnType': 'MObject',
                                                  'static': False,
                                                  'typeQualifiers': {'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': 'Remove 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': 'Remove one of the types that this attribute can accept.',
                                                            'inArgs': ['oldType'],
                                                            'outArgs': [],
                                                            'returnInfo': {'doc': '',
                                                                           'qualifiers': [],
                                                                           'type': None},
                                                            'returnType': None,
                                                            'static': False,
                                                            'typeQualifiers': {},
                                                            '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': 'Remove one of the types that this attribute can accept.',
                                                                   'inArgs': ['oldType'],
                                                                   'outArgs': [],
                                                                   'returnInfo': {'doc': '',
                                                                                  'qualifiers': [],
                                                                                  'type': None},
                                                                   'returnType': None,
                                                                   'static': False,
                                                                   'typeQualifiers': {},
                                                                   'types': {'oldType': ('MFnNumericData',
                                                                                         'Type')}}],
                                      'type': [{'argInfo': {},
                                                'args': [],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': 'Function set type',
                                                'inArgs': [],
                                                'outArgs': [],
                                                'returnInfo': {'doc': 'the class type.',
                                                               'qualifiers': [],
                                                               'type': ('MFn',
                                                                        'Type')},
                                                'returnType': ('MFn', 'Type'),
                                                'static': False,
                                                'typeQualifiers': {},
                                                'types': {}}]},
                          'pymelEnums': {}},
  'MFnGeometryData': {'enums': {'ComponentTagCategory': {'valueDocs': {},
                                                         'values': "Enum('ComponentTagCategory', {'kAuto': 0, 'kNull': 1, 'kVerts': 2, 'kEdges': 3, 'kFaces': 4, 'kUnsupported': 5})"},
                                'SubsetState': {'valueDocs': {},
                                                'values': "Enum('SubsetState', {'kInvalidGroup': 0, 'kEmptyGroup': 1, 'kCompleteGroup': 2, 'kPartialGroup': 3})"}},
                      'invertibles': [('setComponentTagContents',
                                       'componentTagContents'),
                                      ('setMatrix', 'getMatrix'),
                                      ('setObjectGroupComponent',
                                       'objectGroupComponent')],
                      'methods': {'addComponentTag': [{'argInfo': {'key': {'doc': 'componentTag key',
                                                                           'type': 'MString'}},
                                                       'args': [('key',
                                                                 'MString',
                                                                 'in')],
                                                       'defaults': {},
                                                       'deprecated': False,
                                                       'doc': 'This method adds a componentTag with the given key to the object.',
                                                       'inArgs': ['key'],
                                                       'outArgs': [],
                                                       'returnInfo': {'doc': '',
                                                                      'qualifiers': [],
                                                                      'type': None},
                                                       'returnType': None,
                                                       'static': False,
                                                       'typeQualifiers': {'key': ['const',
                                                                                  '&']},
                                                       'types': {'key': 'MString'}}],
                                  'addObjectGroup': [{'argInfo': {'id': {'doc': 'group id.',
                                                                         'type': 'uint'}},
                                                      'args': [('id',
                                                                'uint',
                                                                'in')],
                                                      'defaults': {},
                                                      'deprecated': False,
                                                      'doc': 'This 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': 'This 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': 'This 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': 'Returns the name of this class.',
                                                 'inArgs': [],
                                                 'outArgs': [],
                                                 'returnInfo': {'doc': 'Name of this class.',
                                                                'qualifiers': ['*'],
                                                                'type': 'char'},
                                                 'returnType': 'char',
                                                 'static': True,
                                                 'typeQualifiers': {},
                                                 'types': {}}],
                                  'componentTagCategory': [{'argInfo': {'key': {'doc': 'componentTag key',
                                                                                'type': 'MString'}},
                                                            'args': [('key',
                                                                      'MString',
                                                                      'in')],
                                                            'defaults': {},
                                                            'deprecated': False,
                                                            'doc': 'This method returns the category of the component the componentTag with the given key contains.',
                                                            'inArgs': ['key'],
                                                            'outArgs': [],
                                                            'returnInfo': {'doc': 'The type of the specified componentTag component',
                                                                           'qualifiers': [],
                                                                           'type': ('MFnGeometryData',
                                                                                    'ComponentTagCategory')},
                                                            'returnType': ('MFnGeometryData',
                                                                           'ComponentTagCategory'),
                                                            'static': False,
                                                            'typeQualifiers': {'key': ['const',
                                                                                       '&']},
                                                            'types': {'key': 'MString'}}],
                                  'componentTagContents': [{'argInfo': {'key': {'doc': 'componentTag key',
                                                                                'type': 'MString'}},
                                                            'args': [('key',
                                                                      'MString',
                                                                      'in')],
                                                            'defaults': {},
                                                            'deprecated': False,
                                                            'doc': 'This method returns a component which contains the members of the object group with the given id.',
                                                            'inArgs': ['key'],
                                                            'inverse': ('setComponentTagContents',
                                                                        False),
                                                            'outArgs': [],
                                                            'returnInfo': {'doc': 'A component containing the members of the specified object group',
                                                                           'qualifiers': [],
                                                                           'type': 'MObject'},
                                                            'returnType': 'MObject',
                                                            'static': False,
                                                            'typeQualifiers': {'key': ['const',
                                                                                       '&']},
                                                            'types': {'key': 'MString'}}],
                                  'componentTagExpressionSubsetState': [{'argInfo': {'ctg': {'doc': 'the component category the expression must be resolved to',
                                                                                             'type': ('MFnGeometryData',
                                                                                                      'ComponentTagCategory')},
                                                                                     'expression': {'doc': 'componentTag expression',
                                                                                                    'type': 'MString'}},
                                                                         'args': [('expression',
                                                                                   'MString',
                                                                                   'in'),
                                                                                  ('ctg',
                                                                                   ('MFnGeometryData',
                                                                                    'ComponentTagCategory'),
                                                                                   'in')],
                                                                         'defaults': {'ctg': ('MFnGeometryData',
                                                                                              'ComponentTagCategory',
                                                                                              'kAuto')},
                                                                         'deprecated': False,
                                                                         'doc': 'This method returns the state of the contents of the component that is defined by the given componentTag expression',
                                                                         'inArgs': ['expression',
                                                                                    'ctg'],
                                                                         'outArgs': [],
                                                                         'returnInfo': {'doc': 'The state of the contents of the resolved expression',
                                                                                        'qualifiers': [],
                                                                                        'type': ('MFnGeometryData',
                                                                                                 'SubsetState')},
                                                                         'returnType': ('MFnGeometryData',
                                                                                        'SubsetState'),
                                                                         'static': False,
                                                                         'typeQualifiers': {'expression': ['const',
                                                                                                           '&']},
                                                                         'types': {'ctg': ('MFnGeometryData',
                                                                                           'ComponentTagCategory'),
                                                                                   'expression': 'MString'}}],
                                  'componentTagType': [{'argInfo': {'key': {'doc': 'componentTag key',
                                                                            'type': 'MString'}},
                                                        'args': [('key',
                                                                  'MString',
                                                                  'in')],
                                                        'defaults': {},
                                                        'deprecated': False,
                                                        'doc': 'This method returns the type of the component the componentTag with the given key contains.',
                                                        'inArgs': ['key'],
                                                        'outArgs': [],
                                                        'returnInfo': {'doc': 'The type of the specified componentTag component',
                                                                       'qualifiers': [],
                                                                       'type': ('MFn',
                                                                                'Type')},
                                                        'returnType': ('MFn',
                                                                       'Type'),
                                                        'static': False,
                                                        'typeQualifiers': {'key': ['const',
                                                                                   '&']},
                                                        'types': {'key': 'MString'}}],
                                  'componentTags': [{'argInfo': {'keys': {'doc': 'storage for the array of keys',
                                                                          'type': 'MStringArray'}},
                                                     'args': [('keys',
                                                               'MStringArray',
                                                               'out')],
                                                     'defaults': {},
                                                     'deprecated': False,
                                                     'doc': 'Get the componentTag keys associated with the geometry data.',
                                                     'inArgs': [],
                                                     'outArgs': ['keys'],
                                                     'returnInfo': {'doc': '',
                                                                    'qualifiers': [],
                                                                    'type': None},
                                                     'returnType': None,
                                                     'static': False,
                                                     'typeQualifiers': {'keys': ['&']},
                                                     'types': {'keys': 'MStringArray'}}],
                                  'copyObjectGroups': [{'argInfo': {'inGeom': {'doc': 'the geometry data to be copied',
                                                                               'type': 'MObject'}},
                                                        'args': [('inGeom',
                                                                  'MObject',
                                                                  'in')],
                                                        'defaults': {},
                                                        'deprecated': False,
                                                        'doc': 'Copies 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': 'Get 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'}}],
                                  'hasComponentTag': [{'argInfo': {'key': {'doc': 'componentTag key',
                                                                           'type': 'MString'}},
                                                       'args': [('key',
                                                                 'MString',
                                                                 'in')],
                                                       'defaults': {},
                                                       'deprecated': False,
                                                       'doc': 'This method returns true if a componentTag with the given key is contained in the data.',
                                                       'inArgs': ['key'],
                                                       'outArgs': [],
                                                       'returnInfo': {'doc': 'True is there is a componentTag with the given key, false otherwise',
                                                                      'qualifiers': [],
                                                                      'type': 'bool'},
                                                       'returnType': 'bool',
                                                       'static': False,
                                                       'typeQualifiers': {'key': ['const',
                                                                                  '&']},
                                                       'types': {'key': 'MString'}}],
                                  'hasObjectGroup': [{'argInfo': {'id': {'doc': 'group id.',
                                                                         'type': 'uint'}},
                                                      'args': [('id',
                                                                'uint',
                                                                'in')],
                                                      'defaults': {},
                                                      'deprecated': False,
                                                      'doc': 'This 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': {'id': ['unsigned']},
                                                      'types': {'id': 'uint'}}],
                                  'matrixIsIdentity': [{'argInfo': {},
                                                        'args': [],
                                                        'defaults': {},
                                                        'deprecated': False,
                                                        'doc': 'Return 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': {},
                                                        'types': {}}],
                                  'matrixIsNotIdentity': [{'argInfo': {},
                                                           'args': [],
                                                           'defaults': {},
                                                           'deprecated': False,
                                                           'doc': 'Return 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': {},
                                                           'types': {}}],
                                  'objectGroup': [{'argInfo': {'index': {'doc': 'index in the group array.',
                                                                         'type': 'uint'}},
                                                   'args': [('index',
                                                             'uint',
                                                             'out')],
                                                   'defaults': {},
                                                   'deprecated': False,
                                                   'doc': "This 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': 'uint'},
                                                   'returnType': 'uint',
                                                   'static': False,
                                                   'typeQualifiers': {'index': ['unsigned']},
                                                   'types': {'index': 'uint'}}],
                                  'objectGroupComponent': [{'argInfo': {'id': {'doc': 'group id.',
                                                                               'type': 'uint'}},
                                                            'args': [('id',
                                                                      'uint',
                                                                      'in')],
                                                            'defaults': {},
                                                            'deprecated': False,
                                                            'doc': 'This 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': {'id': ['unsigned']},
                                                            'types': {'id': 'uint'}}],
                                  'objectGroupCount': [{'argInfo': {},
                                                        'args': [],
                                                        'defaults': {},
                                                        'deprecated': False,
                                                        'doc': 'This method returns the number of object groups contained by the object.',
                                                        'inArgs': [],
                                                        'outArgs': [],
                                                        'returnInfo': {'doc': 'The number of object groups',
                                                                       'qualifiers': [],
                                                                       'type': 'uint'},
                                                        'returnType': 'uint',
                                                        'static': False,
                                                        'typeQualifiers': {},
                                                        'types': {}}],
                                  'objectGroupSubsetState': [{'argInfo': {'id': {'doc': 'group id.',
                                                                                 'type': 'uint'}},
                                                              'args': [('id',
                                                                        'uint',
                                                                        'in')],
                                                              'defaults': {},
                                                              'deprecated': False,
                                                              'doc': 'This method returns the state of the contents of the component that the object group with the given id contains.',
                                                              'inArgs': ['id'],
                                                              'outArgs': [],
                                                              'returnInfo': {'doc': 'The group contents of the specified object group component',
                                                                             'qualifiers': [],
                                                                             'type': ('MFnGeometryData',
                                                                                      'SubsetState')},
                                                              'returnType': ('MFnGeometryData',
                                                                             'SubsetState'),
                                                              'static': False,
                                                              'typeQualifiers': {'id': ['unsigned']},
                                                              'types': {'id': 'uint'}}],
                                  'objectGroupType': [{'argInfo': {'id': {'doc': 'group id.',
                                                                          'type': 'uint'}},
                                                       'args': [('id',
                                                                 'uint',
                                                                 'in')],
                                                       'defaults': {},
                                                       'deprecated': False,
                                                       'doc': 'This 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': {'id': ['unsigned']},
                                                       'types': {'id': 'uint'}}],
                                  'removeComponentTag': [{'argInfo': {'key': {'doc': 'componentTag key',
                                                                              'type': 'MString'}},
                                                          'args': [('key',
                                                                    'MString',
                                                                    'in')],
                                                          'defaults': {},
                                                          'deprecated': False,
                                                          'doc': 'This method removes a componentTag with the given key from the object.',
                                                          'inArgs': ['key'],
                                                          'outArgs': [],
                                                          'returnInfo': {'doc': '',
                                                                         'qualifiers': [],
                                                                         'type': None},
                                                          'returnType': None,
                                                          'static': False,
                                                          'typeQualifiers': {'key': ['const',
                                                                                     '&']},
                                                          'types': {'key': 'MString'}}],
                                  'removeObjectGroup': [{'argInfo': {'id': {'doc': 'group id.',
                                                                            'type': 'uint'}},
                                                         'args': [('id',
                                                                   'uint',
                                                                   'in')],
                                                         'defaults': {},
                                                         'deprecated': False,
                                                         'doc': 'This 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': 'This 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'}}],
                                  'renameComponentTag': [{'argInfo': {'key': {'doc': 'componentTag key to be altered',
                                                                              'type': 'MString'},
                                                                      'newKey': {'doc': 'the new componentTag key to be used',
                                                                                 'type': 'MString'}},
                                                          'args': [('key',
                                                                    'MString',
                                                                    'in'),
                                                                   ('newKey',
                                                                    'MString',
                                                                    'in')],
                                                          'defaults': {},
                                                          'deprecated': False,
                                                          'doc': 'This method renames a componentTag with the given key to a new key.',
                                                          'inArgs': ['key',
                                                                     'newKey'],
                                                          'outArgs': [],
                                                          'returnInfo': {'doc': '',
                                                                         'qualifiers': [],
                                                                         'type': None},
                                                          'returnType': None,
                                                          'static': False,
                                                          'typeQualifiers': {'key': ['const',
                                                                                     '&'],
                                                                             'newKey': ['const',
                                                                                        '&']},
                                                          'types': {'key': 'MString',
                                                                    'newKey': 'MString'}}],
                                  'resolveComponentTagExpression': [{'argInfo': {'ctg': {'doc': 'the component category the expression must be resolved to',
                                                                                         'type': ('MFnGeometryData',
                                                                                                  'ComponentTagCategory')},
                                                                                 'expression': {'doc': 'componentTag expression',
                                                                                                'type': 'MString'}},
                                                                     'args': [('expression',
                                                                               'MString',
                                                                               'in'),
                                                                              ('ctg',
                                                                               ('MFnGeometryData',
                                                                                'ComponentTagCategory'),
                                                                               'in')],
                                                                     'defaults': {'ctg': ('MFnGeometryData',
                                                                                          'ComponentTagCategory',
                                                                                          'kAuto')},
                                                                     'deprecated': False,
                                                                     'doc': 'This method returns the resolved component that is defined by the given componentTag expression',
                                                                     'inArgs': ['expression',
                                                                                'ctg'],
                                                                     'outArgs': [],
                                                                     'returnInfo': {'doc': 'A component containing the members of the specified object group',
                                                                                    'qualifiers': [],
                                                                                    'type': 'MObject'},
                                                                     'returnType': 'MObject',
                                                                     'static': False,
                                                                     'typeQualifiers': {'expression': ['const',
                                                                                                       '&']},
                                                                     'types': {'ctg': ('MFnGeometryData',
                                                                                       'ComponentTagCategory'),
                                                                               'expression': 'MString'}}],
                                  'setComponentTagContents': [{'argInfo': {'component': {'doc': 'new component for specified componentTag. The component should be an MObject created from any function set derived from MFnComponent (ie. MFnSingleIndexedComponent, MFnDoubleIndexedComponent, MFnTripleIndexedComponent)',
                                                                                         'type': 'MObject'},
                                                                           'key': {'doc': 'key of componentTag to set',
                                                                                   'type': 'MString'}},
                                                               'args': [('key',
                                                                         'MString',
                                                                         'in'),
                                                                        ('component',
                                                                         'MObject',
                                                                         'in')],
                                                               'defaults': {},
                                                               'deprecated': False,
                                                               'doc': 'This method sets the members of the object group with the given id to be only those in the given component.',
                                                               'inArgs': ['key',
                                                                          'component'],
                                                               'inverse': ('componentTagContents',
                                                                           True),
                                                               'outArgs': [],
                                                               'returnInfo': {'doc': '',
                                                                              'qualifiers': [],
                                                                              'type': None},
                                                               'returnType': None,
                                                               'static': False,
                                                               'typeQualifiers': {'component': ['&'],
                                                                                  'key': ['const',
                                                                                          '&']},
                                                               'types': {'component': 'MObject',
                                                                         'key': 'MString'}}],
                                  'setMatrix': [{'argInfo': {'matrix': {'doc': 'the new matrix to be set',
                                                                        'type': 'MMatrix'}},
                                                 'args': [('matrix',
                                                           'MMatrix',
                                                           'in')],
                                                 'defaults': {},
                                                 'deprecated': False,
                                                 'doc': 'Reset 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': 'This 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': 'Function set type',
                                            'inArgs': [],
                                            'outArgs': [],
                                            'returnInfo': {'doc': 'the class type.',
                                                           'qualifiers': [],
                                                           'type': ('MFn',
                                                                    'Type')},
                                            'returnType': ('MFn', 'Type'),
                                            'static': False,
                                            'typeQualifiers': {},
                                            'types': {}}]},
                      'pymelEnums': {'ComponentTagCategory': "Enum('ComponentTagCategory', [('auto', 0), ('kAuto', 0), ('null', 1), ('kNull', 1), ('verts', 2), ('kVerts', 2), ('edges', 3), ('kEdges', 3), ('faces', 4), ('kFaces', 4), ('unsupported', 5), ('kUnsupported', 5)], multiKeys=True)",
                                     'SubsetState': "Enum('SubsetState', [('invalidGroup', 0), ('kInvalidGroup', 0), ('emptyGroup', 1), ('kEmptyGroup', 1), ('completeGroup', 2), ('kCompleteGroup', 2), ('partialGroup', 3), ('kPartialGroup', 3)], multiKeys=True)"},
                      'pymelMethods': {'componentTagContents': 'getComponentTagContents',
                                       'objectGroupComponent': 'getObjectGroupComponent'}},
  'MFnGeometryFilter': {'enums': {},
                        'invertibles': [('setEnvelope', 'envelope')],
                        'methods': {'className': [{'argInfo': {},
                                                   'args': [],
                                                   'defaults': {},
                                                   'deprecated': False,
                                                   'doc': 'Returns the name of this class.',
                                                   'inArgs': [],
                                                   'outArgs': [],
                                                   'returnInfo': {'doc': 'Name of this class.',
                                                                  'qualifiers': ['*'],
                                                                  'type': 'char'},
                                                   'returnType': 'char',
                                                   'static': True,
                                                   'typeQualifiers': {},
                                                   'types': {}}],
                                    'deformerSet': [{'argInfo': {},
                                                     'args': [],
                                                     'defaults': {},
                                                     'deprecated': False,
                                                     'doc': 'Returns 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': {},
                                                     'types': {}}],
                                    'envelope': [{'argInfo': {},
                                                  'args': [],
                                                  'defaults': {},
                                                  'deprecated': False,
                                                  'doc': 'Returns the envelope value.',
                                                  'inArgs': [],
                                                  'inverse': ('setEnvelope',
                                                              False),
                                                  'outArgs': [],
                                                  'returnInfo': {'doc': 'The envelope value',
                                                                 'qualifiers': [],
                                                                 'type': 'float'},
                                                  'returnType': 'float',
                                                  'static': False,
                                                  'typeQualifiers': {},
                                                  'types': {}}],
                                    'getComponentAtIndex': [{'argInfo': {'index': {'doc': 'the plug index for which the component is requested',
                                                                                   'type': 'uint'}},
                                                             'args': [('index',
                                                                       'uint',
                                                                       'in')],
                                                             'defaults': {},
                                                             'deprecated': False,
                                                             'doc': 'Get the component used for the ith deformed geometry.',
                                                             'inArgs': ['index'],
                                                             'outArgs': [],
                                                             'returnInfo': {'doc': 'MObject representing the component, if successfull and returned nullObj, it would mean complete component',
                                                                            'qualifiers': [],
                                                                            'type': 'MObject'},
                                                             'returnType': 'MObject',
                                                             'static': False,
                                                             'typeQualifiers': {'index': ['unsigned']},
                                                             'types': {'index': 'uint'}}],
                                    'getInputGeometry': [{'argInfo': {'geomList': {'doc': 'storage for the returned array',
                                                                                   'type': 'MObjectArray'}},
                                                          'args': [('geomList',
                                                                    'MObjectArray',
                                                                    'out')],
                                                          'defaults': {},
                                                          'deprecated': False,
                                                          'doc': 'This 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': 'The 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': 'The 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': 'Returns the groupId at the specified plug index.',
                                                        'inArgs': ['index'],
                                                        'outArgs': [],
                                                        'returnInfo': {'doc': 'The groupId at the specified index',
                                                                       'qualifiers': [],
                                                                       'type': 'uint'},
                                                        'returnType': 'uint',
                                                        'static': False,
                                                        'typeQualifiers': {'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': 'Returns the plug index corresponding to the groupId.',
                                                         'inArgs': ['groupId'],
                                                         'outArgs': [],
                                                         'returnInfo': {'doc': 'The plug index corresponding to the groupId',
                                                                        'qualifiers': [],
                                                                        'type': 'uint'},
                                                         'returnType': 'uint',
                                                         'static': False,
                                                         'typeQualifiers': {'groupId': ['unsigned']},
                                                         'types': {'groupId': 'uint'}}],
                                    'indexForOutputConnection': [{'argInfo': {'connectionIndex': {'doc': 'the connection index',
                                                                                                  'type': 'uint'}},
                                                                  'args': [('connectionIndex',
                                                                            'uint',
                                                                            'in')],
                                                                  'defaults': {},
                                                                  'deprecated': False,
                                                                  'doc': "Returns 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': 'uint'},
                                                                  'returnType': 'uint',
                                                                  'static': False,
                                                                  'typeQualifiers': {'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': 'Returns the plug index for the specified output shape.',
                                                             'inArgs': ['shape'],
                                                             'outArgs': [],
                                                             'returnInfo': {'doc': 'The plug index leading to the specified shape',
                                                                            'qualifiers': [],
                                                                            'type': 'uint'},
                                                             'returnType': 'uint',
                                                             'static': False,
                                                             'typeQualifiers': {'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': 'Returns 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': {'index': ['unsigned']},
                                                           'types': {'index': 'uint'}}],
                                    'numOutputConnections': [{'argInfo': {},
                                                              'args': [],
                                                              'defaults': {},
                                                              'deprecated': False,
                                                              'doc': 'Returns 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': 'uint'},
                                                              'returnType': 'uint',
                                                              'static': False,
                                                              'typeQualifiers': {},
                                                              'types': {}}],
                                    'outputShapeAtIndex': [{'argInfo': {'index': {'doc': 'the plug index for the output shape',
                                                                                  'type': 'uint'}},
                                                            'args': [('index',
                                                                      'uint',
                                                                      'in')],
                                                            'defaults': {},
                                                            'deprecated': False,
                                                            'doc': 'Returns 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': {'index': ['unsigned']},
                                                            'types': {'index': 'uint'}}],
                                    'setEnvelope': [{'argInfo': {'envelope': {'doc': 'envelope value',
                                                                              'type': 'float'}},
                                                     'args': [('envelope',
                                                               'float',
                                                               'in')],
                                                     'defaults': {},
                                                     'deprecated': False,
                                                     'doc': 'Sets the envelope value.',
                                                     'inArgs': ['envelope'],
                                                     'inverse': ('envelope',
                                                                 True),
                                                     'outArgs': [],
                                                     'returnInfo': {'doc': '',
                                                                    'qualifiers': [],
                                                                    'type': None},
                                                     'returnType': None,
                                                     'static': False,
                                                     'typeQualifiers': {},
                                                     'types': {'envelope': 'float'}}],
                                    'type': [{'argInfo': {},
                                              'args': [],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': 'Function set type',
                                              'inArgs': [],
                                              'outArgs': [],
                                              'returnInfo': {'doc': 'the class type.',
                                                             'qualifiers': [],
                                                             'type': ('MFn',
                                                                      'Type')},
                                              'returnType': ('MFn', 'Type'),
                                              'static': False,
                                              'typeQualifiers': {},
                                              'types': {}}]},
                        'pymelEnums': {},
                        'pymelMethods': {'envelope': 'getEnvelope'}},
  'MFnGravityField': {'enums': {},
                      'invertibles': [('setDirection', 'direction')],
                      'methods': {'className': [{'argInfo': {},
                                                 'args': [],
                                                 'defaults': {},
                                                 'deprecated': False,
                                                 'doc': 'Returns the name of this class.',
                                                 'inArgs': [],
                                                 'outArgs': [],
                                                 'returnInfo': {'doc': 'Name of this class.',
                                                                'qualifiers': ['*'],
                                                                'type': 'char'},
                                                 'returnType': 'char',
                                                 'static': True,
                                                 'typeQualifiers': {},
                                                 'types': {}}],
                                  'direction': [{'argInfo': {},
                                                 'args': [],
                                                 'defaults': {},
                                                 'deprecated': False,
                                                 'doc': 'Returns 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': {},
                                                 'types': {}}],
                                  'setDirection': [{'argInfo': {'gravityDirection': {'doc': 'A vector representing direction.',
                                                                                     'type': 'MVector'}},
                                                    'args': [('gravityDirection',
                                                              'MVector',
                                                              'in')],
                                                    'defaults': {},
                                                    'deprecated': False,
                                                    'doc': 'Sets 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': 'Function set type',
                                            'inArgs': [],
                                            'outArgs': [],
                                            'returnInfo': {'doc': 'the class type.',
                                                           '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': 'Returns the name of this class.',
                                                'inArgs': [],
                                                'outArgs': [],
                                                'returnInfo': {'doc': 'Name of this class.',
                                                               'qualifiers': ['*'],
                                                               'type': 'char'},
                                                'returnType': 'char',
                                                'static': True,
                                                'typeQualifiers': {},
                                                'types': {}}],
                                 'create': [{'argInfo': {'parent': {'doc': 'parent DAG node (usually none)',
                                                                    'type': 'MObject'}},
                                             'args': [('parent',
                                                       'MObject',
                                                       'in')],
                                             'defaults': {'parent': 'MObject::kNullObj'},
                                             'deprecated': False,
                                             'doc': 'Creates a new fbik effector.',
                                             'inArgs': ['parent'],
                                             'outArgs': [],
                                             'returnInfo': {'doc': 'A handle to the new object',
                                                            'qualifiers': [],
                                                            'type': 'MObject'},
                                             'returnType': 'MObject',
                                             'static': False,
                                             'typeQualifiers': {},
                                             'types': {'parent': 'MObject'}}],
                                 'getAuxiliaryEffectors': [{'argInfo': {'effs': {'doc': 'the auxiliary effectors for this effector',
                                                                                 'type': 'MObjectArray'}},
                                                            'args': [('effs',
                                                                      'MObjectArray',
                                                                      'out')],
                                                            'defaults': {},
                                                            'deprecated': False,
                                                            'doc': 'Returns 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': 'Retrieve 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': {},
                                                  'types': {}}],
                                 'getPivotOffset': [{'argInfo': {},
                                                     'args': [],
                                                     'defaults': {},
                                                     'deprecated': False,
                                                     'doc': 'Retrieve the pivot offset of this effector.',
                                                     'inArgs': [],
                                                     'inverse': ('setPivotOffset',
                                                                 False),
                                                     'outArgs': [],
                                                     'returnInfo': {'doc': 'Pivot offset vector.',
                                                                    'qualifiers': [],
                                                                    'type': 'MVector'},
                                                     'returnType': 'MVector',
                                                     'static': False,
                                                     'typeQualifiers': {},
                                                     'types': {}}],
                                 'setEffColor': [{'argInfo': {'color': {'doc': 'the new color',
                                                                        'type': 'MColor'}},
                                                  'args': [('color',
                                                            'MColor',
                                                            'in')],
                                                  'defaults': {},
                                                  'deprecated': False,
                                                  'doc': 'Set 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': 'Set 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': 'Function set type',
                                           'inArgs': [],
                                           'outArgs': [],
                                           'returnInfo': {'doc': 'the class type.',
                                                          'qualifiers': [],
                                                          'type': ('MFn',
                                                                   'Type')},
                                           'returnType': ('MFn', 'Type'),
                                           'static': False,
                                           'typeQualifiers': {},
                                           'types': {}}]},
                     'pymelEnums': {}},
  'MFnIkEffector': {'enums': {},
                    'methods': {'className': [{'argInfo': {},
                                               'args': [],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': 'Returns the name of this class.',
                                               'inArgs': [],
                                               'outArgs': [],
                                               'returnInfo': {'doc': 'Name of this class.',
                                                              'qualifiers': ['*'],
                                                              'type': 'char'},
                                               'returnType': 'char',
                                               'static': True,
                                               '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': 'Creates 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': {},
                                            'types': {'parent': 'MObject'}}],
                                'type': [{'argInfo': {},
                                          'args': [],
                                          'defaults': {},
                                          'deprecated': False,
                                          'doc': 'Function set type',
                                          'inArgs': [],
                                          'outArgs': [],
                                          'returnInfo': {'doc': 'the class type.',
                                                         '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': [('setEffector', 'getEffector'),
                                  ('setPriority', 'priority'),
                                  ('setSolver', 'solver'),
                                  ('setStartJoint', 'getStartJoint'),
                                  ('setStickiness', 'stickiness'),
                                  ('setWeight', 'weight')],
                  'methods': {'className': [{'argInfo': {},
                                             'args': [],
                                             'defaults': {},
                                             'deprecated': False,
                                             'doc': 'Returns the name of this class.',
                                             'inArgs': [],
                                             'outArgs': [],
                                             'returnInfo': {'doc': 'Name of this class.',
                                                            'qualifiers': ['*'],
                                                            'type': 'char'},
                                             'returnType': 'char',
                                             'static': True,
                                             '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': 'Creates 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': {'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': "Get 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': "This 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': 'Gets 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': {},
                                            'types': {}}],
                              'priority': [{'argInfo': {},
                                            'args': [],
                                            'defaults': {},
                                            'deprecated': False,
                                            'doc': 'Get 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': 'uint'},
                                            'returnType': 'uint',
                                            'static': False,
                                            'typeQualifiers': {},
                                            'types': {}}],
                              'setEffector': [{'argInfo': {'effectorPath': {'doc': 'The path for the effector',
                                                                            'type': 'MDagPath'}},
                                               'args': [('effectorPath',
                                                         'MDagPath',
                                                         'in')],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': "Set 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': 'Sets 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': {},
                                               'types': {'poWeight': 'double'}}],
                              'setPriority': [{'argInfo': {'priority': {'doc': 'The priority to set for this handle',
                                                                        'type': 'uint'}},
                                               'args': [('priority',
                                                         'uint',
                                                         'in')],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': 'Set 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': 'Set 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': 'Set 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': "This 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': "This 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': "Set 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': {},
                                                 'types': {'stickiness': ('MFnIkHandle',
                                                                          'Stickiness')}}],
                              'setWeight': [{'argInfo': {'weight': {'doc': 'The weight value to be set',
                                                                    'type': 'double'}},
                                             'args': [('weight',
                                                       'double',
                                                       'in')],
                                             'defaults': {},
                                             'deprecated': False,
                                             'doc': 'Specifies 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': {},
                                             'types': {'weight': 'double'}}],
                              'solver': [{'argInfo': {},
                                          'args': [],
                                          'defaults': {},
                                          'deprecated': False,
                                          'doc': 'Returns 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': {},
                                          'types': {}}],
                              'stickiness': [{'argInfo': {},
                                              'args': [],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': 'Get 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': {},
                                              'types': {}}],
                              'type': [{'argInfo': {},
                                        'args': [],
                                        'defaults': {},
                                        'deprecated': False,
                                        'doc': 'Function set type',
                                        'inArgs': [],
                                        'outArgs': [],
                                        'returnInfo': {'doc': 'the class type.',
                                                       'qualifiers': [],
                                                       'type': ('MFn', 'Type')},
                                        'returnType': ('MFn', 'Type'),
                                        'static': False,
                                        'typeQualifiers': {},
                                        'types': {}}],
                              'weight': [{'argInfo': {},
                                          'args': [],
                                          'defaults': {},
                                          'deprecated': False,
                                          'doc': 'Get 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': {},
                                          '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': {'Axis': {'valueDocs': {},
                                    'values': "Enum('Axis', {'kXAxis': 0, 'kYAxis': 1, 'kZAxis': 2, 'kNone': 3})"}},
                 'invertibles': [('setDegreesOfFreedom', 'getDegreesOfFreedom'),
                                 ('setMaxRotateDampXRange',
                                  'maxRotateDampXRange'),
                                 ('setMaxRotateDampXStrength',
                                  'maxRotateDampXStrength'),
                                 ('setMaxRotateDampYRange',
                                  'maxRotateDampYRange'),
                                 ('setMaxRotateDampYStrength',
                                  'maxRotateDampYStrength'),
                                 ('setMaxRotateDampZRange',
                                  'maxRotateDampZRange'),
                                 ('setMaxRotateDampZStrength',
                                  'maxRotateDampZStrength'),
                                 ('setMinRotateDampXRange',
                                  'minRotateDampXRange'),
                                 ('setMinRotateDampXStrength',
                                  'minRotateDampXStrength'),
                                 ('setMinRotateDampYRange',
                                  'minRotateDampYRange'),
                                 ('setMinRotateDampYStrength',
                                  'minRotateDampYStrength'),
                                 ('setMinRotateDampZRange',
                                  'minRotateDampZRange'),
                                 ('setMinRotateDampZStrength',
                                  'minRotateDampZStrength'),
                                 ('setOrientation', 'getOrientation'),
                                 ('setPreferedAngle', 'getPreferedAngle'),
                                 ('setPreferredAngle', 'getPreferredAngle'),
                                 ('setScaleOrientation', 'getScaleOrientation'),
                                 ('setSegmentScale', 'getSegmentScale'),
                                 ('setStiffness', 'getStiffness')],
                 'methods': {'className': [{'argInfo': {},
                                            'args': [],
                                            'defaults': {},
                                            'deprecated': False,
                                            'doc': 'Returns the name of this class.',
                                            'inArgs': [],
                                            'outArgs': [],
                                            'returnInfo': {'doc': 'Name of this class.',
                                                           'qualifiers': ['*'],
                                                           'type': 'char'},
                                            'returnType': 'char',
                                            'static': True,
                                            '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': 'Create 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': {},
                                         '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': 'Get 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'}}],
                             'getOrientation': [{'argInfo': {'quaternion': {'doc': 'the quaternion representing the jointOrient',
                                                                            'type': 'MQuaternion'}},
                                                 'args': [('quaternion',
                                                           'MQuaternion',
                                                           'out')],
                                                 'defaults': {},
                                                 'deprecated': False,
                                                 'doc': 'Get 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': 'Get 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': 'Get the orientation of the coordinate axes.',
                                                 'inArgs': [],
                                                 'inverse': ('setOrientation',
                                                             False),
                                                 'outArgs': ['rotation',
                                                             'order'],
                                                 'returnInfo': {'doc': '',
                                                                'qualifiers': [],
                                                                'type': None},
                                                 'returnType': None,
                                                 'static': False,
                                                 'typeQualifiers': {'order': ['&']},
                                                 'types': {'order': ('MTransformationMatrix',
                                                                     'RotationOrder'),
                                                           'rotation': 'double__array3'}}],
                             'getPreferedAngle': [{'argInfo': {'rotation': {'doc': '',
                                                                            'type': 'double__array3'}},
                                                   'args': [('rotation',
                                                             'double__array3',
                                                             'out')],
                                                   'defaults': {},
                                                   'deprecated': True,
                                                   'doc': 'Obsolete - use correctly spelled getPreferredAngle.',
                                                   'inArgs': [],
                                                   'inverse': ('setPreferedAngle',
                                                               False),
                                                   'outArgs': ['rotation'],
                                                   'returnInfo': {'doc': '',
                                                                  'qualifiers': [],
                                                                  'type': None},
                                                   'returnType': None,
                                                   'static': False,
                                                   'typeQualifiers': {},
                                                   'types': {'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': 'Get 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': {},
                                                    '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': 'Get 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': 'Get 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': ['&']},
                                                      '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': 'Get 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': {},
                                                  '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': 'Get 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': {},
                                               'types': {'stiffness': 'double__array3'}}],
                             'hikJointName': [{'argInfo': {},
                                               'args': [],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': 'Get 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': {},
                                               'types': {}}],
                             'maxRotateDampXRange': [{'argInfo': {},
                                                      'args': [],
                                                      'defaults': {},
                                                      'deprecated': False,
                                                      'doc': 'Get 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': {},
                                                      'types': {}}],
                             'maxRotateDampXStrength': [{'argInfo': {},
                                                         'args': [],
                                                         'defaults': {},
                                                         'deprecated': False,
                                                         'doc': 'Get 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': {},
                                                         'types': {}}],
                             'maxRotateDampYRange': [{'argInfo': {},
                                                      'args': [],
                                                      'defaults': {},
                                                      'deprecated': False,
                                                      'doc': 'Get 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': {},
                                                      'types': {}}],
                             'maxRotateDampYStrength': [{'argInfo': {},
                                                         'args': [],
                                                         'defaults': {},
                                                         'deprecated': False,
                                                         'doc': 'Get 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': {},
                                                         'types': {}}],
                             'maxRotateDampZRange': [{'argInfo': {},
                                                      'args': [],
                                                      'defaults': {},
                                                      'deprecated': False,
                                                      'doc': 'Get 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': {},
                                                      'types': {}}],
                             'maxRotateDampZStrength': [{'argInfo': {},
                                                         'args': [],
                                                         'defaults': {},
                                                         'deprecated': False,
                                                         'doc': 'Get 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': {},
                                                         'types': {}}],
                             'minRotateDampXRange': [{'argInfo': {},
                                                      'args': [],
                                                      'defaults': {},
                                                      'deprecated': False,
                                                      'doc': 'Get 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': {},
                                                      'types': {}}],
                             'minRotateDampXStrength': [{'argInfo': {},
                                                         'args': [],
                                                         'defaults': {},
                                                         'deprecated': False,
                                                         'doc': 'Get 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': {},
                                                         'types': {}}],
                             'minRotateDampYRange': [{'argInfo': {},
                                                      'args': [],
                                                      'defaults': {},
                                                      'deprecated': False,
                                                      'doc': 'Get 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': {},
                                                      'types': {}}],
                             'minRotateDampYStrength': [{'argInfo': {},
                                                         'args': [],
                                                         'defaults': {},
                                                         'deprecated': False,
                                                         'doc': 'Get 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': {},
                                                         'types': {}}],
                             'minRotateDampZRange': [{'argInfo': {},
                                                      'args': [],
                                                      'defaults': {},
                                                      'deprecated': False,
                                                      'doc': 'Get 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': {},
                                                      'types': {}}],
                             'minRotateDampZStrength': [{'argInfo': {},
                                                         'args': [],
                                                         'defaults': {},
                                                         'deprecated': False,
                                                         'doc': 'Get 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': {},
                                                         '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': 'Set 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': {},
                                                      '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': 'Set the maximum of the damping range in X',
                                                         'inArgs': ['angle'],
                                                         'inverse': ('maxRotateDampXRange',
                                                                     True),
                                                         'outArgs': [],
                                                         'returnInfo': {'doc': '',
                                                                        'qualifiers': [],
                                                                        'type': None},
                                                         'returnType': None,
                                                         'static': False,
                                                         'typeQualifiers': {},
                                                         'types': {'angle': 'double'}}],
                             'setMaxRotateDampXStrength': [{'argInfo': {'angle': {'doc': 'The new damping strength value',
                                                                                  'type': 'double'}},
                                                            'args': [('angle',
                                                                      'double',
                                                                      'in')],
                                                            'defaults': {},
                                                            'deprecated': False,
                                                            'doc': 'Set the maximum of the damping strength in X.',
                                                            'inArgs': ['angle'],
                                                            'inverse': ('maxRotateDampXStrength',
                                                                        True),
                                                            'outArgs': [],
                                                            'returnInfo': {'doc': '',
                                                                           'qualifiers': [],
                                                                           'type': None},
                                                            'returnType': None,
                                                            'static': False,
                                                            'typeQualifiers': {},
                                                            'types': {'angle': 'double'}}],
                             'setMaxRotateDampYRange': [{'argInfo': {'angle': {'doc': 'the damping range to set',
                                                                               'type': 'double'}},
                                                         'args': [('angle',
                                                                   'double',
                                                                   'in')],
                                                         'defaults': {},
                                                         'deprecated': False,
                                                         'doc': 'Set the maximum of the damping range in Y',
                                                         'inArgs': ['angle'],
                                                         'inverse': ('maxRotateDampYRange',
                                                                     True),
                                                         'outArgs': [],
                                                         'returnInfo': {'doc': '',
                                                                        'qualifiers': [],
                                                                        'type': None},
                                                         'returnType': None,
                                                         'static': False,
                                                         'typeQualifiers': {},
                                                         'types': {'angle': 'double'}}],
                             'setMaxRotateDampYStrength': [{'argInfo': {'angle': {'doc': 'The new damping strength value',
                                                                                  'type': 'double'}},
                                                            'args': [('angle',
                                                                      'double',
                                                                      'in')],
                                                            'defaults': {},
                                                            'deprecated': False,
                                                            'doc': 'Set the maximum of the damping strength in Y.',
                                                            'inArgs': ['angle'],
                                                            'inverse': ('maxRotateDampYStrength',
                                                                        True),
                                                            'outArgs': [],
                                                            'returnInfo': {'doc': '',
                                                                           'qualifiers': [],
                                                                           'type': None},
                                                            'returnType': None,
                                                            'static': False,
                                                            'typeQualifiers': {},
                                                            'types': {'angle': 'double'}}],
                             'setMaxRotateDampZRange': [{'argInfo': {'angle': {'doc': 'the damping range to set',
                                                                               'type': 'double'}},
                                                         'args': [('angle',
                                                                   'double',
                                                                   'in')],
                                                         'defaults': {},
                                                         'deprecated': False,
                                                         'doc': 'Set the maximum of the damping range in Z',
                                                         'inArgs': ['angle'],
                                                         'inverse': ('maxRotateDampZRange',
                                                                     True),
                                                         'outArgs': [],
                                                         'returnInfo': {'doc': '',
                                                                        'qualifiers': [],
                                                                        'type': None},
                                                         'returnType': None,
                                                         'static': False,
                                                         'typeQualifiers': {},
                                                         'types': {'angle': 'double'}}],
                             'setMaxRotateDampZStrength': [{'argInfo': {'angle': {'doc': 'The new damping strength value',
                                                                                  'type': 'double'}},
                                                            'args': [('angle',
                                                                      'double',
                                                                      'in')],
                                                            'defaults': {},
                                                            'deprecated': False,
                                                            'doc': 'Set the maximum of the damping strength in Z.',
                                                            'inArgs': ['angle'],
                                                            'inverse': ('maxRotateDampZStrength',
                                                                        True),
                                                            'outArgs': [],
                                                            'returnInfo': {'doc': '',
                                                                           'qualifiers': [],
                                                                           'type': None},
                                                            'returnType': None,
                                                            'static': False,
                                                            'typeQualifiers': {},
                                                            'types': {'angle': 'double'}}],
                             'setMinRotateDampXRange': [{'argInfo': {'angle': {'doc': 'The damping range to set',
                                                                               'type': 'double'}},
                                                         'args': [('angle',
                                                                   'double',
                                                                   'in')],
                                                         'defaults': {},
                                                         'deprecated': False,
                                                         'doc': 'Set the minimum of the damping range in X',
                                                         'inArgs': ['angle'],
                                                         'inverse': ('minRotateDampXRange',
                                                                     True),
                                                         'outArgs': [],
                                                         'returnInfo': {'doc': '',
                                                                        'qualifiers': [],
                                                                        'type': None},
                                                         'returnType': None,
                                                         'static': False,
                                                         'typeQualifiers': {},
                                                         'types': {'angle': 'double'}}],
                             'setMinRotateDampXStrength': [{'argInfo': {'angle': {'doc': 'The new damping strength value',
                                                                                  'type': 'double'}},
                                                            'args': [('angle',
                                                                      'double',
                                                                      'in')],
                                                            'defaults': {},
                                                            'deprecated': False,
                                                            'doc': 'Set the maximum of the damping strength in Z.',
                                                            'inArgs': ['angle'],
                                                            'inverse': ('minRotateDampXStrength',
                                                                        True),
                                                            'outArgs': [],
                                                            'returnInfo': {'doc': '',
                                                                           'qualifiers': [],
                                                                           'type': None},
                                                            'returnType': None,
                                                            'static': False,
                                                            'typeQualifiers': {},
                                                            'types': {'angle': 'double'}}],
                             'setMinRotateDampYRange': [{'argInfo': {'angle': {'doc': 'the damping range to set',
                                                                               'type': 'double'}},
                                                         'args': [('angle',
                                                                   'double',
                                                                   'in')],
                                                         'defaults': {},
                                                         'deprecated': False,
                                                         'doc': 'Set the minimum of the damping range in Y',
                                                         'inArgs': ['angle'],
                                                         'inverse': ('minRotateDampYRange',
                                                                     True),
                                                         'outArgs': [],
                                                         'returnInfo': {'doc': '',
                                                                        'qualifiers': [],
                                                                        'type': None},
                                                         'returnType': None,
                                                         'static': False,
                                                         'typeQualifiers': {},
                                                         'types': {'angle': 'double'}}],
                             'setMinRotateDampYStrength': [{'argInfo': {'angle': {'doc': 'The new damping strength value',
                                                                                  'type': 'double'}},
                                                            'args': [('angle',
                                                                      'double',
                                                                      'in')],
                                                            'defaults': {},
                                                            'deprecated': False,
                                                            'doc': 'Set the maximum of the damping strength in Y.',
                                                            'inArgs': ['angle'],
                                                            'inverse': ('minRotateDampYStrength',
                                                                        True),
                                                            'outArgs': [],
                                                            'returnInfo': {'doc': '',
                                                                           'qualifiers': [],
                                                                           'type': None},
                                                            'returnType': None,
                                                            'static': False,
                                                            'typeQualifiers': {},
                                                            'types': {'angle': 'double'}}],
                             'setMinRotateDampZRange': [{'argInfo': {'angle': {'doc': 'the damping range to set',
                                                                               'type': 'double'}},
                                                         'args': [('angle',
                                                                   'double',
                                                                   'in')],
                                                         'defaults': {},
                                                         'deprecated': False,
                                                         'doc': 'Set the minimum of the damping range in Z',
                                                         'inArgs': ['angle'],
                                                         'inverse': ('minRotateDampZRange',
                                                                     True),
                                                         'outArgs': [],
                                                         'returnInfo': {'doc': '',
                                                                        'qualifiers': [],
                                                                        'type': None},
                                                         'returnType': None,
                                                         'static': False,
                                                         'typeQualifiers': {},
                                                         'types': {'angle': 'double'}}],
                             'setMinRotateDampZStrength': [{'argInfo': {'angle': {'doc': 'The new damping strength value',
                                                                                  'type': 'double'}},
                                                            'args': [('angle',
                                                                      'double',
                                                                      'in')],
                                                            'defaults': {},
                                                            'deprecated': False,
                                                            'doc': 'Set the minimum of the damping strength in Z.',
                                                            'inArgs': ['angle'],
                                                            'inverse': ('minRotateDampZStrength',
                                                                        True),
                                                            'outArgs': [],
                                                            'returnInfo': {'doc': '',
                                                                           'qualifiers': [],
                                                                           'type': None},
                                                            'returnType': None,
                                                            'static': False,
                                                            'typeQualifiers': {},
                                                            'types': {'angle': 'double'}}],
                             'setOrientation': [{'argInfo': {'quaternion': {'doc': 'the joint orientation',
                                                                            'type': 'MQuaternion'}},
                                                 'args': [('quaternion',
                                                           'MQuaternion',
                                                           'in')],
                                                 'defaults': {},
                                                 'deprecated': False,
                                                 'doc': 'Set 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': 'Set 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': 'Set the orientation of the coordinate axes.',
                                                 'inArgs': ['rotation',
                                                            'order'],
                                                 'inverse': ('getOrientation',
                                                             True),
                                                 'outArgs': [],
                                                 'returnInfo': {'doc': '',
                                                                'qualifiers': [],
                                                                'type': None},
                                                 'returnType': None,
                                                 'static': False,
                                                 'typeQualifiers': {'rotation': ['const']},
                                                 'types': {'order': ('MTransformationMatrix',
                                                                     'RotationOrder'),
                                                           'rotation': 'double__array3'}}],
                             'setPreferedAngle': [{'argInfo': {'rotation': {'doc': '',
                                                                            'type': 'double__array3'}},
                                                   'args': [('rotation',
                                                             'double__array3',
                                                             'in')],
                                                   'defaults': {},
                                                   'deprecated': True,
                                                   'doc': 'Obsolete - use correctly spelled setPreferredAngle.',
                                                   'inArgs': ['rotation'],
                                                   'inverse': ('getPreferedAngle',
                                                               True),
                                                   'outArgs': [],
                                                   'returnInfo': {'doc': '',
                                                                  'qualifiers': [],
                                                                  'type': None},
                                                   'returnType': None,
                                                   'static': False,
                                                   'typeQualifiers': {'rotation': ['const']},
                                                   'types': {'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': 'Set 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': [('quaternion',
                                                                'MQuaternion',
                                                                'in')],
                                                      'defaults': {},
                                                      'deprecated': False,
                                                      'doc': 'Set 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': ['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': 'Set 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': {'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': 'Set 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': 'Set 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': 'Function set type',
                                       'inArgs': [],
                                       'outArgs': [],
                                       'returnInfo': {'doc': 'the class type.',
                                                      'qualifiers': [],
                                                      'type': ('MFn', 'Type')},
                                       'returnType': ('MFn', 'Type'),
                                       'static': False,
                                       'typeQualifiers': {},
                                       'types': {}}]},
                 'pymelEnums': {'Axis': "Enum('Axis', [('XAxis', 0), ('kXAxis', 0), ('YAxis', 1), ('kYAxis', 1), ('ZAxis', 2), ('kZAxis', 2), ('none', 3), ('kNone', 3)], multiKeys=True)"},
                 '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': [('setMaxIterations', 'maxIterations'),
                                  ('setTolerance', 'tolerance')],
                  'methods': {'className': [{'argInfo': {},
                                             'args': [],
                                             'defaults': {},
                                             'deprecated': False,
                                             'doc': 'Returns the name of this class.',
                                             'inArgs': [],
                                             'outArgs': [],
                                             'returnInfo': {'doc': 'Name of this class.',
                                                            'qualifiers': ['*'],
                                                            'type': 'char'},
                                             'returnType': 'char',
                                             'static': True,
                                             'typeQualifiers': {},
                                             'types': {}}],
                              'maxIterations': [{'argInfo': {},
                                                 'args': [],
                                                 'defaults': {},
                                                 'deprecated': False,
                                                 'doc': 'Returns 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': 'uint'},
                                                 'returnType': 'uint',
                                                 'static': False,
                                                 'typeQualifiers': {},
                                                 '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': 'Sets 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': 'Sets the tolerance used when solving.',
                                                'inArgs': ['tolerance'],
                                                'inverse': ('tolerance', True),
                                                'outArgs': [],
                                                'returnInfo': {'doc': '',
                                                               'qualifiers': [],
                                                               'type': None},
                                                'returnType': None,
                                                'static': False,
                                                'typeQualifiers': {},
                                                'types': {'tolerance': 'double'}}],
                              'tolerance': [{'argInfo': {},
                                             'args': [],
                                             'defaults': {},
                                             'deprecated': False,
                                             'doc': 'Returns 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': {},
                                             'types': {}}],
                              'type': [{'argInfo': {},
                                        'args': [],
                                        'defaults': {},
                                        'deprecated': False,
                                        'doc': 'Function set type',
                                        'inArgs': [],
                                        'outArgs': [],
                                        'returnInfo': {'doc': 'the class type.',
                                                       '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': 'Returns the name of this class.',
                                                'inArgs': [],
                                                'outArgs': [],
                                                'returnInfo': {'doc': 'Name of this class.',
                                                               'qualifiers': ['*'],
                                                               'type': 'char'},
                                                'returnType': 'char',
                                                'static': True,
                                                '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': 'Return 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': {'bufferName': ['*'],
                                                                      'camera': ['const'],
                                                                      'renderLayer': ['const'],
                                                                      'sceneName': ['const',
                                                                                    '&']},
                                                   'types': {'bufferName': 'MString',
                                                             'camera': 'MObject',
                                                             'frameNumber': 'double',
                                                             'pathType': ('MCommonRenderSettingsData',
                                                                          'MpathType'),
                                                             'renderLayer': 'MObject',
                                                             'sceneName': 'MString'}}],
                                 'sourceCamera': [{'argInfo': {'currentCamera': {'doc': '',
                                                                                 'type': 'MObject'}},
                                                   'args': [('currentCamera',
                                                             'MObject',
                                                             'in')],
                                                   'defaults': {},
                                                   'deprecated': False,
                                                   'doc': '',
                                                   'inArgs': ['currentCamera'],
                                                   'outArgs': [],
                                                   'returnInfo': {'doc': '',
                                                                  'qualifiers': [],
                                                                  'type': 'MObject'},
                                                   'returnType': 'MObject',
                                                   'static': False,
                                                   'typeQualifiers': {'currentCamera': ['const',
                                                                                        '&']},
                                                   'types': {'currentCamera': 'MObject'}}],
                                 'sourceLayer': [{'argInfo': {'currentLayer': {'doc': '',
                                                                               'type': 'MObject'}},
                                                  'args': [('currentLayer',
                                                            'MObject',
                                                            'in')],
                                                  'defaults': {},
                                                  'deprecated': False,
                                                  'doc': '',
                                                  'inArgs': ['currentLayer'],
                                                  'outArgs': [],
                                                  'returnInfo': {'doc': '',
                                                                 'qualifiers': [],
                                                                 'type': 'MObject'},
                                                  'returnType': 'MObject',
                                                  'static': False,
                                                  'typeQualifiers': {'currentLayer': ['const',
                                                                                      '&']},
                                                  'types': {'currentLayer': 'MObject'}}],
                                 'type': [{'argInfo': {},
                                           'args': [],
                                           'defaults': {},
                                           'deprecated': False,
                                           'doc': 'Function set type',
                                           'inArgs': [],
                                           'outArgs': [],
                                           'returnInfo': {'doc': 'the class type.',
                                                          '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': 'Returns 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'}}],
                               'className': [{'argInfo': {},
                                              'args': [],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': 'Returns the name of this class.',
                                              'inArgs': [],
                                              'outArgs': [],
                                              'returnInfo': {'doc': 'Name of this class.',
                                                             'qualifiers': ['*'],
                                                             'type': 'char'},
                                              'returnType': 'char',
                                              'static': True,
                                              'typeQualifiers': {},
                                              'types': {}}],
                               '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': 'Returns 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': {'instancerMatrix': ['&'],
                                                                            'paths': ['&']},
                                                         'types': {'instancerMatrix': 'MMatrix',
                                                                   'p': 'int',
                                                                   'paths': 'MDagPathArray'}}],
                               'particleCount': [{'argInfo': {},
                                                  'args': [],
                                                  'defaults': {},
                                                  'deprecated': False,
                                                  'doc': 'Returns the number of particles feeding the active instancer',
                                                  'inArgs': [],
                                                  'outArgs': [],
                                                  'returnInfo': {'doc': 'See description.',
                                                                 'qualifiers': [],
                                                                 'type': 'int'},
                                                  'returnType': 'int',
                                                  'static': False,
                                                  'typeQualifiers': {},
                                                  'types': {}}],
                               'type': [{'argInfo': {},
                                         'args': [],
                                         'defaults': {},
                                         'deprecated': False,
                                         'doc': 'Function set type',
                                         'inArgs': [],
                                         'outArgs': [],
                                         'returnInfo': {'doc': 'the class type.',
                                                        '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': 'Extract 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'}}],
                                  'array': [{'argInfo': {},
                                             'args': [],
                                             'defaults': {},
                                             'deprecated': False,
                                             'doc': 'Return 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': {},
                                             'types': {}}],
                                  'className': [{'argInfo': {},
                                                 'args': [],
                                                 'defaults': {},
                                                 'deprecated': False,
                                                 'doc': 'Returns the name of this class.',
                                                 'inArgs': [],
                                                 'outArgs': [],
                                                 'returnInfo': {'doc': 'Name of this class.',
                                                                'qualifiers': ['*'],
                                                                'type': 'char'},
                                                 'returnType': 'char',
                                                 'static': True,
                                                 'typeQualifiers': {},
                                                 'types': {}}],
                                  'copyTo': [{'argInfo': {'dest': {'doc': 'the MIntArray to populate',
                                                                   'type': 'MIntArray'}},
                                              'args': [('dest',
                                                        'MIntArray',
                                                        'out')],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': 'Copy 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': 'Create 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': {},
                                              'types': {}},
                                             {'argInfo': {'arr': {'doc': 'the data to use when initializing this instance',
                                                                  'type': 'MIntArray'}},
                                              'args': [('arr',
                                                        'MIntArray',
                                                        'in')],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': 'Create 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': {'arr': ['const',
                                                                         '&']},
                                              'types': {'arr': 'MIntArray'}}],
                                  'length': [{'argInfo': {},
                                              'args': [],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': 'Return the number of integers in the instance.',
                                              'inArgs': [],
                                              'outArgs': [],
                                              'returnInfo': {'doc': 'The number of integers in the instance',
                                                             'qualifiers': [],
                                                             'type': 'uint'},
                                              'returnType': 'uint',
                                              'static': False,
                                              'typeQualifiers': {},
                                              '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': 'Set the integer element at the specified index of this array.',
                                           'inArgs': ['element', 'index'],
                                           'outArgs': [],
                                           'returnInfo': {'doc': '',
                                                          'qualifiers': [],
                                                          'type': None},
                                           'returnType': None,
                                           'static': False,
                                           'typeQualifiers': {'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': 'Set 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': 'Function set type',
                                            'inArgs': [],
                                            'outArgs': [],
                                            'returnInfo': {'doc': 'the class type.',
                                                           'qualifiers': [],
                                                           'type': ('MFn',
                                                                    'Type')},
                                            'returnType': ('MFn', 'Type'),
                                            'static': False,
                                            'typeQualifiers': {},
                                            'types': {}}]},
                      'pymelEnums': {}},
  'MFnKeyframeDelta': {'enums': {},
                       'methods': {'className': [{'argInfo': {},
                                                  'args': [],
                                                  'defaults': {},
                                                  'deprecated': False,
                                                  'doc': 'Returns the name of this class.',
                                                  'inArgs': [],
                                                  'outArgs': [],
                                                  'returnInfo': {'doc': 'Name of this class.',
                                                                 'qualifiers': ['*'],
                                                                 'type': 'char'},
                                                  'returnType': 'char',
                                                  'static': True,
                                                  'typeQualifiers': {},
                                                  'types': {}}],
                                   'keyIndex': [{'argInfo': {},
                                                 'args': [],
                                                 'defaults': {},
                                                 'deprecated': False,
                                                 'doc': 'The 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': 'uint'},
                                                 'returnType': 'uint',
                                                 'static': False,
                                                 'typeQualifiers': {},
                                                 'types': {}}],
                                   'paramCurve': [{'argInfo': {},
                                                   'args': [],
                                                   'defaults': {},
                                                   'deprecated': False,
                                                   'doc': 'Return 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': {},
                                                   'types': {}}],
                                   'type': [{'argInfo': {},
                                             'args': [],
                                             'defaults': {},
                                             'deprecated': False,
                                             'doc': 'Function set type',
                                             'inArgs': [],
                                             'outArgs': [],
                                             'returnInfo': {'doc': 'the class type.',
                                                            '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': 'Returns the name of this class.',
                                                           'inArgs': [],
                                                           'outArgs': [],
                                                           'returnInfo': {'doc': 'Name of this class.',
                                                                          'qualifiers': ['*'],
                                                                          'type': 'char'},
                                                           'returnType': 'char',
                                                           'static': True,
                                                           'typeQualifiers': {},
                                                           'types': {}}],
                                            'deltaType': [{'argInfo': {},
                                                           'args': [],
                                                           'defaults': {},
                                                           'deprecated': False,
                                                           'doc': 'Indicates 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': {},
                                                           'types': {}}],
                                            'keyIndex': [{'argInfo': {},
                                                          'args': [],
                                                          'defaults': {},
                                                          'deprecated': False,
                                                          'doc': 'The 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': 'uint'},
                                                          'returnType': 'uint',
                                                          'static': False,
                                                          'typeQualifiers': {},
                                                          'types': {}}],
                                            'replacedValue': [{'argInfo': {},
                                                               'args': [],
                                                               'defaults': {},
                                                               'deprecated': False,
                                                               'doc': 'The 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': {},
                                                               'types': {}}],
                                            'time': [{'argInfo': {},
                                                      'args': [],
                                                      'defaults': {},
                                                      'deprecated': False,
                                                      'doc': 'The 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': {},
                                                      'types': {}}],
                                            'type': [{'argInfo': {},
                                                      'args': [],
                                                      'defaults': {},
                                                      'deprecated': False,
                                                      'doc': 'Function set type',
                                                      'inArgs': [],
                                                      'outArgs': [],
                                                      'returnInfo': {'doc': 'the class type.',
                                                                     'qualifiers': [],
                                                                     'type': ('MFn',
                                                                              'Type')},
                                                      'returnType': ('MFn',
                                                                     'Type'),
                                                      'static': False,
                                                      'typeQualifiers': {},
                                                      'types': {}}],
                                            'value': [{'argInfo': {},
                                                       'args': [],
                                                       'defaults': {},
                                                       'deprecated': False,
                                                       'doc': 'The value of the key that was added or removed.',
                                                       'inArgs': [],
                                                       'outArgs': [],
                                                       'returnInfo': {'doc': 'A double value',
                                                                      'qualifiers': [],
                                                                      'type': 'double'},
                                                       'returnType': 'double',
                                                       'static': False,
                                                       'typeQualifiers': {},
                                                       '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': 'Returns the name of this class.',
                                                                'inArgs': [],
                                                                'outArgs': [],
                                                                'returnInfo': {'doc': 'Name of this class.',
                                                                               'qualifiers': ['*'],
                                                                               'type': 'char'},
                                                                'returnType': 'char',
                                                                'static': True,
                                                                'typeQualifiers': {},
                                                                'types': {}}],
                                                 'deltaType': [{'argInfo': {},
                                                                'args': [],
                                                                'defaults': {},
                                                                'deprecated': False,
                                                                'doc': 'Indicates 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': {},
                                                                'types': {}}],
                                                 'endTime': [{'argInfo': {},
                                                              'args': [],
                                                              'defaults': {},
                                                              'deprecated': False,
                                                              'doc': 'Returns 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': {},
                                                              'types': {}}],
                                                 'getTimes': [{'argInfo': {'times': {'doc': 'MTimeArray to store all time values.',
                                                                                     'type': 'MTimeArray'}},
                                                               'args': [('times',
                                                                         'MTimeArray',
                                                                         'out')],
                                                               'defaults': {},
                                                               'deprecated': False,
                                                               'doc': 'Returns 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': {'times': ['&']},
                                                               'types': {'times': 'MTimeArray'}}],
                                                 'getValues': [{'argInfo': {'values': {'doc': 'MDoubleArray to store values.',
                                                                                       'type': 'MDoubleArray'}},
                                                                'args': [('values',
                                                                          'MDoubleArray',
                                                                          'out')],
                                                                'defaults': {},
                                                                'deprecated': False,
                                                                'doc': 'Returns 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': {'values': ['&']},
                                                                'types': {'values': 'MDoubleArray'}}],
                                                 'numKeys': [{'argInfo': {},
                                                              'args': [],
                                                              'defaults': {},
                                                              'deprecated': False,
                                                              'doc': 'Total number of keys involved in this add or remove operation.',
                                                              'inArgs': [],
                                                              'outArgs': [],
                                                              'returnInfo': {'doc': '',
                                                                             'qualifiers': [],
                                                                             'type': 'uint'},
                                                              'returnType': 'uint',
                                                              'static': False,
                                                              'typeQualifiers': {},
                                                              'types': {}}],
                                                 'startTime': [{'argInfo': {},
                                                                'args': [],
                                                                'defaults': {},
                                                                'deprecated': False,
                                                                'doc': 'An 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': {},
                                                                'types': {}}],
                                                 'type': [{'argInfo': {},
                                                           'args': [],
                                                           'defaults': {},
                                                           'deprecated': False,
                                                           'doc': 'Function set type',
                                                           'inArgs': [],
                                                           'outArgs': [],
                                                           'returnInfo': {'doc': 'the class type.',
                                                                          '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': 'Returns the name of this class.',
                                                           'inArgs': [],
                                                           'outArgs': [],
                                                           'returnInfo': {'doc': 'Name of this class.',
                                                                          'qualifiers': ['*'],
                                                                          'type': 'char'},
                                                           'returnType': 'char',
                                                           'static': True,
                                                           'typeQualifiers': {},
                                                           'types': {}}],
                                            'isBreakdown': [{'argInfo': {},
                                                             'args': [],
                                                             'defaults': {},
                                                             'deprecated': False,
                                                             'doc': 'Returns 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': {},
                                                             'types': {}}],
                                            'type': [{'argInfo': {},
                                                      'args': [],
                                                      'defaults': {},
                                                      'deprecated': False,
                                                      'doc': 'Function set type',
                                                      'inArgs': [],
                                                      'outArgs': [],
                                                      'returnInfo': {'doc': 'the class type.',
                                                                     'qualifiers': [],
                                                                     'type': ('MFn',
                                                                              'Type')},
                                                      'returnType': ('MFn',
                                                                     'Type'),
                                                      'static': False,
                                                      'typeQualifiers': {},
                                                      'types': {}}],
                                            'wasBreakdown': [{'argInfo': {},
                                                              'args': [],
                                                              'defaults': {},
                                                              'deprecated': False,
                                                              'doc': 'Returns 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': {},
                                                              'types': {}}]},
                                'pymelEnums': {}},
  'MFnKeyframeDeltaInfType': {'enums': {},
                              'methods': {'className': [{'argInfo': {},
                                                         'args': [],
                                                         'defaults': {},
                                                         'deprecated': False,
                                                         'doc': 'Returns the name of this class.',
                                                         'inArgs': [],
                                                         'outArgs': [],
                                                         'returnInfo': {'doc': 'Name of this class.',
                                                                        'qualifiers': ['*'],
                                                                        'type': 'char'},
                                                         'returnType': 'char',
                                                         'static': True,
                                                         'typeQualifiers': {},
                                                         'types': {}}],
                                          'currentInfinityType': [{'argInfo': {},
                                                                   'args': [],
                                                                   'defaults': {},
                                                                   'deprecated': False,
                                                                   'doc': 'The current infinity type.',
                                                                   'inArgs': [],
                                                                   'outArgs': [],
                                                                   'returnInfo': {'doc': 'The current InfinityType for the curve',
                                                                                  'qualifiers': [],
                                                                                  'type': ('MFnAnimCurve',
                                                                                           'InfinityType')},
                                                                   'returnType': ('MFnAnimCurve',
                                                                                  'InfinityType'),
                                                                   'static': False,
                                                                   'typeQualifiers': {},
                                                                   'types': {}}],
                                          'isPreInfinity': [{'argInfo': {},
                                                             'args': [],
                                                             'defaults': {},
                                                             'deprecated': False,
                                                             'doc': 'This 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': {},
                                                             'types': {}}],
                                          'previousInfinityType': [{'argInfo': {},
                                                                    'args': [],
                                                                    'defaults': {},
                                                                    'deprecated': False,
                                                                    'doc': 'The previous infinity type.',
                                                                    'inArgs': [],
                                                                    'outArgs': [],
                                                                    'returnInfo': {'doc': 'The previous infinityType for the curve.',
                                                                                   'qualifiers': [],
                                                                                   'type': ('MFnAnimCurve',
                                                                                            'InfinityType')},
                                                                    'returnType': ('MFnAnimCurve',
                                                                                   'InfinityType'),
                                                                    'static': False,
                                                                    'typeQualifiers': {},
                                                                    'types': {}}],
                                          'type': [{'argInfo': {},
                                                    'args': [],
                                                    'defaults': {},
                                                    'deprecated': False,
                                                    'doc': 'Function set type',
                                                    'inArgs': [],
                                                    'outArgs': [],
                                                    'returnInfo': {'doc': 'the class type.',
                                                                   'qualifiers': [],
                                                                   'type': ('MFn',
                                                                            'Type')},
                                                    'returnType': ('MFn',
                                                                   'Type'),
                                                    'static': False,
                                                    'typeQualifiers': {},
                                                    'types': {}}]},
                              'pymelEnums': {}},
  'MFnKeyframeDeltaMove': {'enums': {},
                           'methods': {'className': [{'argInfo': {},
                                                      'args': [],
                                                      'defaults': {},
                                                      'deprecated': False,
                                                      'doc': 'Returns the name of this class.',
                                                      'inArgs': [],
                                                      'outArgs': [],
                                                      'returnInfo': {'doc': 'Name of this class.',
                                                                     'qualifiers': ['*'],
                                                                     'type': 'char'},
                                                      'returnType': 'char',
                                                      'static': True,
                                                      'typeQualifiers': {},
                                                      'types': {}}],
                                       'currentTime': [{'argInfo': {},
                                                        'args': [],
                                                        'defaults': {},
                                                        'deprecated': False,
                                                        'doc': 'The 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': {},
                                                        'types': {}}],
                                       'currentValue': [{'argInfo': {},
                                                         'args': [],
                                                         'defaults': {},
                                                         'deprecated': False,
                                                         'doc': 'The 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': {},
                                                         'types': {}}],
                                       'keyIndex': [{'argInfo': {},
                                                     'args': [],
                                                     'defaults': {},
                                                     'deprecated': False,
                                                     'doc': 'The 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': 'uint'},
                                                     'returnType': 'uint',
                                                     'static': False,
                                                     'typeQualifiers': {},
                                                     'types': {}}],
                                       'previousIndex': [{'argInfo': {},
                                                          'args': [],
                                                          'defaults': {},
                                                          'deprecated': False,
                                                          'doc': 'The 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': 'uint'},
                                                          'returnType': 'uint',
                                                          'static': False,
                                                          'typeQualifiers': {},
                                                          'types': {}}],
                                       'previousTime': [{'argInfo': {},
                                                         'args': [],
                                                         'defaults': {},
                                                         'deprecated': False,
                                                         'doc': 'The 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': {},
                                                         'types': {}}],
                                       'previousValue': [{'argInfo': {},
                                                          'args': [],
                                                          'defaults': {},
                                                          'deprecated': False,
                                                          'doc': 'The 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': {},
                                                          'types': {}}],
                                       'type': [{'argInfo': {},
                                                 'args': [],
                                                 'defaults': {},
                                                 'deprecated': False,
                                                 'doc': 'Function set type',
                                                 'inArgs': [],
                                                 'outArgs': [],
                                                 'returnInfo': {'doc': 'the class type.',
                                                                'qualifiers': [],
                                                                'type': ('MFn',
                                                                         'Type')},
                                                 'returnType': ('MFn', 'Type'),
                                                 'static': False,
                                                 'typeQualifiers': {},
                                                 'types': {}}]},
                           'pymelEnums': {}},
  'MFnKeyframeDeltaScale': {'enums': {},
                            'methods': {'className': [{'argInfo': {},
                                                       'args': [],
                                                       'defaults': {},
                                                       'deprecated': False,
                                                       'doc': 'Returns the name of this class.',
                                                       'inArgs': [],
                                                       'outArgs': [],
                                                       'returnInfo': {'doc': 'Name of this class.',
                                                                      'qualifiers': ['*'],
                                                                      'type': 'char'},
                                                       'returnType': 'char',
                                                       'static': True,
                                                       'typeQualifiers': {},
                                                       'types': {}}],
                                        'currentEndTime': [{'argInfo': {},
                                                            'args': [],
                                                            'defaults': {},
                                                            'deprecated': False,
                                                            'doc': 'The current end time.',
                                                            'inArgs': [],
                                                            'outArgs': [],
                                                            'returnInfo': {'doc': 'An MTime value',
                                                                           'qualifiers': [],
                                                                           'type': 'MTime'},
                                                            'returnType': 'MTime',
                                                            'static': False,
                                                            'typeQualifiers': {},
                                                            'types': {}}],
                                        'currentStartTime': [{'argInfo': {},
                                                              'args': [],
                                                              'defaults': {},
                                                              'deprecated': False,
                                                              'doc': 'The current scale time (after scaling has been performed).',
                                                              'inArgs': [],
                                                              'outArgs': [],
                                                              'returnInfo': {'doc': 'An MTime value',
                                                                             'qualifiers': [],
                                                                             'type': 'MTime'},
                                                              'returnType': 'MTime',
                                                              'static': False,
                                                              'typeQualifiers': {},
                                                              'types': {}}],
                                        'endTime': [{'argInfo': {},
                                                     'args': [],
                                                     'defaults': {},
                                                     'deprecated': False,
                                                     'doc': 'The end time of the scaling block.',
                                                     'inArgs': [],
                                                     'outArgs': [],
                                                     'returnInfo': {'doc': 'An MTime value',
                                                                    'qualifiers': [],
                                                                    'type': 'MTime'},
                                                     'returnType': 'MTime',
                                                     'static': False,
                                                     'typeQualifiers': {},
                                                     'types': {}}],
                                        'pivotTime': [{'argInfo': {},
                                                       'args': [],
                                                       'defaults': {},
                                                       'deprecated': False,
                                                       'doc': 'The pivot point of the scale (in time).',
                                                       'inArgs': [],
                                                       'outArgs': [],
                                                       'returnInfo': {'doc': 'An MTime value',
                                                                      'qualifiers': [],
                                                                      'type': 'MTime'},
                                                       'returnType': 'MTime',
                                                       'static': False,
                                                       'typeQualifiers': {},
                                                       'types': {}}],
                                        'startTime': [{'argInfo': {},
                                                       'args': [],
                                                       'defaults': {},
                                                       'deprecated': False,
                                                       'doc': 'The start time of the scaling block.',
                                                       'inArgs': [],
                                                       'outArgs': [],
                                                       'returnInfo': {'doc': 'An MTime value',
                                                                      'qualifiers': [],
                                                                      'type': 'MTime'},
                                                       'returnType': 'MTime',
                                                       'static': False,
                                                       'typeQualifiers': {},
                                                       'types': {}}],
                                        'type': [{'argInfo': {},
                                                  'args': [],
                                                  'defaults': {},
                                                  'deprecated': False,
                                                  'doc': 'Function set type',
                                                  'inArgs': [],
                                                  'outArgs': [],
                                                  'returnInfo': {'doc': 'the class type.',
                                                                 'qualifiers': [],
                                                                 'type': ('MFn',
                                                                          'Type')},
                                                  'returnType': ('MFn', 'Type'),
                                                  'static': False,
                                                  'typeQualifiers': {},
                                                  'types': {}}]},
                            'pymelEnums': {}},
  'MFnKeyframeDeltaTangent': {'enums': {},
                              'methods': {'className': [{'argInfo': {},
                                                         'args': [],
                                                         'defaults': {},
                                                         'deprecated': False,
                                                         'doc': 'Returns the name of this class.',
                                                         'inArgs': [],
                                                         'outArgs': [],
                                                         'returnInfo': {'doc': 'Name of this class.',
                                                                        'qualifiers': ['*'],
                                                                        'type': 'char'},
                                                         'returnType': 'char',
                                                         'static': True,
                                                         'typeQualifiers': {},
                                                         'types': {}}],
                                          'currentTangentType': [{'argInfo': {},
                                                                  'args': [],
                                                                  'defaults': {},
                                                                  'deprecated': False,
                                                                  'doc': 'Returns 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': {},
                                                                  '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': 'Get 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': 'Get 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': "Key'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': {},
                                                           'types': {}}],
                                          'previousTangentType': [{'argInfo': {},
                                                                   'args': [],
                                                                   'defaults': {},
                                                                   'deprecated': False,
                                                                   'doc': 'Returns the previous tangent type.',
                                                                   'inArgs': [],
                                                                   'outArgs': [],
                                                                   'returnInfo': {'doc': 'The previous tangent type.',
                                                                                  'qualifiers': [],
                                                                                  'type': ('MFnAnimCurve',
                                                                                           'TangentType')},
                                                                   'returnType': ('MFnAnimCurve',
                                                                                  'TangentType'),
                                                                   'static': False,
                                                                   'typeQualifiers': {},
                                                                   'types': {}}],
                                          'type': [{'argInfo': {},
                                                    'args': [],
                                                    'defaults': {},
                                                    'deprecated': False,
                                                    'doc': 'Function set type',
                                                    'inArgs': [],
                                                    'outArgs': [],
                                                    'returnInfo': {'doc': 'the class type.',
                                                                   'qualifiers': [],
                                                                   'type': ('MFn',
                                                                            'Type')},
                                                    'returnType': ('MFn',
                                                                   'Type'),
                                                    'static': False,
                                                    'typeQualifiers': {},
                                                    'types': {}}]},
                              'pymelEnums': {}},
  'MFnKeyframeDeltaWeighted': {'enums': {},
                               'methods': {'className': [{'argInfo': {},
                                                          'args': [],
                                                          'defaults': {},
                                                          'deprecated': False,
                                                          'doc': 'Returns the name of this class.',
                                                          'inArgs': [],
                                                          'outArgs': [],
                                                          'returnInfo': {'doc': 'Name of this class.',
                                                                         'qualifiers': ['*'],
                                                                         'type': 'char'},
                                                          'returnType': 'char',
                                                          'static': True,
                                                          'typeQualifiers': {},
                                                          'types': {}}],
                                           'type': [{'argInfo': {},
                                                     'args': [],
                                                     'defaults': {},
                                                     'deprecated': False,
                                                     'doc': 'Function set type',
                                                     'inArgs': [],
                                                     'outArgs': [],
                                                     'returnInfo': {'doc': 'the class type.',
                                                                    'qualifiers': [],
                                                                    'type': ('MFn',
                                                                             'Type')},
                                                     'returnType': ('MFn',
                                                                    'Type'),
                                                     'static': False,
                                                     'typeQualifiers': {},
                                                     'types': {}}],
                                           'wasWeighted': [{'argInfo': {},
                                                            'args': [],
                                                            'defaults': {},
                                                            'deprecated': False,
                                                            'doc': 'Returns 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': {},
                                                            'types': {}}]},
                               'pymelEnums': {}},
  'MFnLambertShader': {'enums': {},
                       'invertibles': [('setAmbientColor', 'ambientColor'),
                                       ('setColor', 'color'),
                                       ('setDiffuseCoeff', 'diffuseCoeff'),
                                       ('setGlowIntensity', 'glowIntensity'),
                                       ('setHideSource', 'hideSource'),
                                       ('setIncandescence', 'incandescence'),
                                       ('setRefractedRayDepthLimit',
                                        'refractedRayDepthLimit'),
                                       ('setRefractiveIndex',
                                        'refractiveIndex'),
                                       ('setRtRefractedColor',
                                        'rtRefractedColor'),
                                       ('setTranslucenceCoeff',
                                        'translucenceCoeff'),
                                       ('setTransparency', 'transparency')],
                       'methods': {'ambientColor': [{'argInfo': {},
                                                     'args': [],
                                                     'defaults': {},
                                                     'deprecated': False,
                                                     'doc': 'Retrieves 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': {},
                                                     'types': {}}],
                                   'className': [{'argInfo': {},
                                                  'args': [],
                                                  'defaults': {},
                                                  'deprecated': False,
                                                  'doc': 'Returns the name of this class.',
                                                  'inArgs': [],
                                                  'outArgs': [],
                                                  'returnInfo': {'doc': 'Name of this class.',
                                                                 'qualifiers': ['*'],
                                                                 'type': 'char'},
                                                  'returnType': 'char',
                                                  'static': True,
                                                  'typeQualifiers': {},
                                                  'types': {}}],
                                   'color': [{'argInfo': {},
                                              'args': [],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': 'Retrieves 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': {},
                                              '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': 'Creates 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': {},
                                               'types': {'UIvisible': 'bool'}}],
                                   'diffuseCoeff': [{'argInfo': {},
                                                     'args': [],
                                                     'defaults': {},
                                                     'deprecated': False,
                                                     'doc': 'Retrieves 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': {},
                                                     'types': {}}],
                                   'glowIntensity': [{'argInfo': {},
                                                      'args': [],
                                                      'defaults': {},
                                                      'deprecated': False,
                                                      'doc': 'Retrieves 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': {},
                                                      'types': {}}],
                                   'hideSource': [{'argInfo': {},
                                                   'args': [],
                                                   'defaults': {},
                                                   'deprecated': False,
                                                   'doc': 'Retrieves 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': {},
                                                   'types': {}}],
                                   'incandescence': [{'argInfo': {},
                                                      'args': [],
                                                      'defaults': {},
                                                      'deprecated': False,
                                                      'doc': 'Retrieves 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': {},
                                                      'types': {}}],
                                   'refractedRayDepthLimit': [{'argInfo': {},
                                                               'args': [],
                                                               'defaults': {},
                                                               'deprecated': False,
                                                               'doc': 'Retrieves 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': {},
                                                               'types': {}}],
                                   'refractiveIndex': [{'argInfo': {},
                                                        'args': [],
                                                        'defaults': {},
                                                        'deprecated': False,
                                                        'doc': 'Retrieves 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': {},
                                                        'types': {}}],
                                   'rtRefractedColor': [{'argInfo': {},
                                                         'args': [],
                                                         'defaults': {},
                                                         'deprecated': False,
                                                         'doc': 'Retrieves 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': {},
                                                         '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': 'Sets 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': 'Sets 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': 'Sets 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': 'Sets 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': 'Sets 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': 'Sets 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': 'Sets 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': 'Sets 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': 'Sets 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': 'Sets 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': 'Sets 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': 'Retrieves 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': {},
                                                          'types': {}}],
                                   'transparency': [{'argInfo': {},
                                                     'args': [],
                                                     'defaults': {},
                                                     'deprecated': False,
                                                     'doc': 'Retrieves 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': {},
                                                     'types': {}}],
                                   'type': [{'argInfo': {},
                                             'args': [],
                                             'defaults': {},
                                             'deprecated': False,
                                             'doc': 'Function set type',
                                             'inArgs': [],
                                             'outArgs': [],
                                             'returnInfo': {'doc': 'the class type.',
                                                            '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': 'Returns the name of this class.',
                                            'inArgs': [],
                                            'outArgs': [],
                                            'returnInfo': {'doc': 'Name of this class.',
                                                           'qualifiers': ['*'],
                                                           'type': 'char'},
                                            'returnType': 'char',
                                            'static': True,
                                            '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': 'Create 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': {'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': 'Get 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': 'Returns 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': {'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': 'Reset 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': {},
                                        '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': 'Set 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': 'Function set type',
                                       'inArgs': [],
                                       'outArgs': [],
                                       'returnInfo': {'doc': 'the class type.',
                                                      'qualifiers': [],
                                                      'type': ('MFn', 'Type')},
                                       'returnType': ('MFn', 'Type'),
                                       'static': False,
                                       'typeQualifiers': {},
                                       'types': {}}]},
                 'pymelEnums': {}},
  'MFnLatticeData': {'enums': {},
                     'methods': {'className': [{'argInfo': {},
                                                'args': [],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': 'Returns the name of this class.',
                                                'inArgs': [],
                                                'outArgs': [],
                                                'returnInfo': {'doc': 'Name of this class.',
                                                               'qualifiers': ['*'],
                                                               'type': 'char'},
                                                'returnType': 'char',
                                                'static': True,
                                                'typeQualifiers': {},
                                                'types': {}}],
                                 'create': [{'argInfo': {},
                                             'args': [],
                                             'defaults': {},
                                             'deprecated': False,
                                             'doc': "This 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': {},
                                             'types': {}}],
                                 'lattice': [{'argInfo': {},
                                              'args': [],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': 'Returns 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': {},
                                              'types': {}}],
                                 'type': [{'argInfo': {},
                                           'args': [],
                                           'defaults': {},
                                           'deprecated': False,
                                           'doc': 'Function set type',
                                           'inArgs': [],
                                           'outArgs': [],
                                           'returnInfo': {'doc': 'the class type.',
                                                          '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': 'Adds 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': 'This 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': {},
                                                      'types': {}}],
                                     'className': [{'argInfo': {},
                                                    'args': [],
                                                    'defaults': {},
                                                    'deprecated': False,
                                                    'doc': 'Returns the name of this class.',
                                                    'inArgs': [],
                                                    'outArgs': [],
                                                    'returnInfo': {'doc': 'Name of this class.',
                                                                   'qualifiers': ['*'],
                                                                   'type': 'char'},
                                                    'returnType': 'char',
                                                    'static': True,
                                                    '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': "Creates 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': {'xDiv': ['unsigned'],
                                                                    'yDiv': ['unsigned'],
                                                                    'zDiv': ['unsigned']},
                                                 'types': {'xDiv': 'uint',
                                                           'yDiv': 'uint',
                                                           'zDiv': 'uint'}}],
                                     'deformLattice': [{'argInfo': {},
                                                        'args': [],
                                                        'defaults': {},
                                                        'deprecated': False,
                                                        'doc': 'This 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': {},
                                                        'types': {}}],
                                     'getAffectedGeometry': [{'argInfo': {'objects': {'doc': 'storage for the returned array',
                                                                                      'type': 'MObjectArray'}},
                                                              'args': [('objects',
                                                                        'MObjectArray',
                                                                        'out')],
                                                              'defaults': {},
                                                              'deprecated': False,
                                                              'doc': 'The 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': 'Retrieve 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': 'Removes 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': 'This method resets the deformed lattice to match the base lattice.',
                                                       'inArgs': ['centerLattice'],
                                                       'outArgs': [],
                                                       'returnInfo': {'doc': '',
                                                                      'qualifiers': [],
                                                                      'type': None},
                                                       'returnType': None,
                                                       'static': False,
                                                       'typeQualifiers': {},
                                                       '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': 'Set 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': 'Function set type',
                                               'inArgs': [],
                                               'outArgs': [],
                                               'returnInfo': {'doc': 'the class type.',
                                                              'qualifiers': [],
                                                              'type': ('MFn',
                                                                       'Type')},
                                               'returnType': ('MFn', 'Type'),
                                               'static': False,
                                               'typeQualifiers': {},
                                               'types': {}}]},
                         'pymelEnums': {}},
  'MFnLayeredShader': {'enums': {},
                       'invertibles': [('setColor', 'color'),
                                       ('setCompositingFlag',
                                        'compositingFlag'),
                                       ('setGlowColor', 'glowColor'),
                                       ('setHardwareColor', 'hardwareColor'),
                                       ('setHardwareShader', 'hardwareShader'),
                                       ('setTransparency', 'transparency')],
                       'methods': {'className': [{'argInfo': {},
                                                  'args': [],
                                                  'defaults': {},
                                                  'deprecated': False,
                                                  'doc': 'Returns the name of this class.',
                                                  'inArgs': [],
                                                  'outArgs': [],
                                                  'returnInfo': {'doc': 'Name of this class.',
                                                                 'qualifiers': ['*'],
                                                                 'type': 'char'},
                                                  'returnType': 'char',
                                                  'static': True,
                                                  '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': 'Retrieves 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': {'lIndex': ['unsigned']},
                                              'types': {'lIndex': 'uint'}}],
                                   'compositingFlag': [{'argInfo': {},
                                                        'args': [],
                                                        'defaults': {},
                                                        'deprecated': False,
                                                        'doc': 'Retrieves 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': {},
                                                        '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': 'Creates 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': {},
                                               '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': 'Retrieves 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': {'lIndex': ['unsigned']},
                                                  'types': {'lIndex': 'uint'}}],
                                   'hardwareColor': [{'argInfo': {},
                                                      'args': [],
                                                      'defaults': {},
                                                      'deprecated': False,
                                                      'doc': 'Retrieves 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': {},
                                                      'types': {}}],
                                   'hardwareShader': [{'argInfo': {},
                                                       'args': [],
                                                       'defaults': {},
                                                       'deprecated': False,
                                                       'doc': 'Retrieves 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': {},
                                                       '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': 'Sets 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': 'Sets 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': 'Sets 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': 'Sets 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': 'Sets 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': 'Sets 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': 'Retrieves 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': {'lIndex': ['unsigned']},
                                                     'types': {'lIndex': 'uint'}}],
                                   'type': [{'argInfo': {},
                                             'args': [],
                                             'defaults': {},
                                             'deprecated': False,
                                             'doc': 'Function set type',
                                             'inArgs': [],
                                             'outArgs': [],
                                             'returnInfo': {'doc': 'the class type.',
                                                            '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': [('setCenterOfIllumination',
                                'centerOfIllumination'),
                               ('setColor', 'color'),
                               ('setIntensity', 'intensity'),
                               ('setNumShadowSamples', 'numShadowSamples'),
                               ('setOpticalFXvisibility',
                                'opticalFXvisibility'),
                               ('setRayDepthLimit', 'rayDepthLimit'),
                               ('setShadowColor', 'shadowColor'),
                               ('setUseRayTraceShadows', 'useRayTraceShadows')],
               'methods': {'centerOfIllumination': [{'argInfo': {},
                                                     'args': [],
                                                     'defaults': {},
                                                     'deprecated': False,
                                                     'doc': 'Retrieves 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': 'linear'},
                                                     'returnType': 'double',
                                                     'static': False,
                                                     'typeQualifiers': {},
                                                     'types': {}}],
                           'className': [{'argInfo': {},
                                          'args': [],
                                          'defaults': {},
                                          'deprecated': False,
                                          'doc': 'Returns the name of this class.',
                                          'inArgs': [],
                                          'outArgs': [],
                                          'returnInfo': {'doc': 'Name of this class.',
                                                         'qualifiers': ['*'],
                                                         'type': 'char'},
                                          'returnType': 'char',
                                          'static': True,
                                          'typeQualifiers': {},
                                          'types': {}}],
                           'color': [{'argInfo': {},
                                      'args': [],
                                      'defaults': {},
                                      'deprecated': False,
                                      'doc': 'Retrieves 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': {},
                                      'types': {}}],
                           'intensity': [{'argInfo': {},
                                          'args': [],
                                          'defaults': {},
                                          'deprecated': False,
                                          'doc': 'Retrieves 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': {},
                                          'types': {}}],
                           'lightAmbient': [{'argInfo': {},
                                             'args': [],
                                             'defaults': {},
                                             'deprecated': False,
                                             'doc': 'Retrieves 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': {},
                                             'types': {}}],
                           'lightDiffuse': [{'argInfo': {},
                                             'args': [],
                                             'defaults': {},
                                             'deprecated': False,
                                             'doc': 'Retrieves 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': {},
                                             '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': 'Returns 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': {},
                                               'types': {'instance': 'int',
                                                         'space': ('MSpace',
                                                                   'Space')}},
                                              {'argInfo': {},
                                               'args': [],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': 'Retrieves 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': {},
                                               'types': {}}],
                           'lightIntensity': [{'argInfo': {},
                                               'args': [],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': 'Retrieves 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': {},
                                               'types': {}}],
                           'lightSpecular': [{'argInfo': {},
                                              'args': [],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': 'Retrieves 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': {},
                                              'types': {}}],
                           'numShadowSamples': [{'argInfo': {},
                                                 'args': [],
                                                 'defaults': {},
                                                 'deprecated': False,
                                                 'doc': 'Retrieves 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': {},
                                                 'types': {}}],
                           'opticalFXvisibility': [{'argInfo': {},
                                                    'args': [],
                                                    'defaults': {},
                                                    'deprecated': False,
                                                    'doc': 'Retrieves 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': {},
                                                    'types': {}}],
                           'rayDepthLimit': [{'argInfo': {},
                                              'args': [],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': 'Retrieves 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': {},
                                              'types': {}}],
                           'setCenterOfIllumination': [{'argInfo': {'dist': {'doc': 'value to which the attribute will be set.',
                                                                             'type': 'double',
                                                                             'unitType': 'linear'}},
                                                        'args': [('dist',
                                                                  'double',
                                                                  'in')],
                                                        'defaults': {},
                                                        'deprecated': False,
                                                        'doc': 'Sets 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': 'Sets 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': 'Sets 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': 'Sets 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': 'Sets 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': 'Sets 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': 'Sets 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': 'Sets 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': 'Retrieves 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': {},
                                            'types': {}}],
                           'type': [{'argInfo': {},
                                     'args': [],
                                     'defaults': {},
                                     'deprecated': False,
                                     'doc': 'Function set type',
                                     'inArgs': [],
                                     'outArgs': [],
                                     'returnInfo': {'doc': 'the class type.',
                                                    'qualifiers': [],
                                                    'type': ('MFn', 'Type')},
                                     'returnType': ('MFn', 'Type'),
                                     'static': False,
                                     'typeQualifiers': {},
                                     'types': {}}],
                           'useRayTraceShadows': [{'argInfo': {},
                                                   'args': [],
                                                   'defaults': {},
                                                   'deprecated': False,
                                                   'doc': 'Retrieves 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': {},
                                                   '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': 'Gets 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': {'index': ['unsigned']},
                                                   'types': {'index': 'uint'}}],
                                        'className': [{'argInfo': {},
                                                       'args': [],
                                                       'defaults': {},
                                                       'deprecated': False,
                                                       'doc': 'Returns the name of this class.',
                                                       'inArgs': [],
                                                       'outArgs': [],
                                                       'returnInfo': {'doc': 'Name of this class.',
                                                                      'qualifiers': ['*'],
                                                                      'type': 'char'},
                                                       'returnType': 'char',
                                                       'static': True,
                                                       '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': 'Creates 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': {'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': 'Gets 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': 'Sets 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': {'defBlindData': ['*']},
                                                        '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': 'Function set type',
                                                  'inArgs': [],
                                                  'outArgs': [],
                                                  'returnInfo': {'doc': 'the class type.',
                                                                 'qualifiers': [],
                                                                 'type': ('MFn',
                                                                          'Type')},
                                                  'returnType': ('MFn', 'Type'),
                                                  'static': False,
                                                  'typeQualifiers': {},
                                                  'types': {}}]},
                            'pymelEnums': {}},
  'MFnManip3D': {'enums': {},
                 'invertibles': [('setDrawPlaneHandles', 'drawPlaneHandles'),
                                 ('setGlobalSize', 'globalSize'),
                                 ('setHandleSize', 'handleSize'),
                                 ('setLineSize', 'lineSize'),
                                 ('setManipScale', 'manipScale'),
                                 ('setVisible', 'isVisible')],
                 'methods': {'className': [{'argInfo': {},
                                            'args': [],
                                            'defaults': {},
                                            'deprecated': False,
                                            'doc': 'Returns the name of this class.',
                                            'inArgs': [],
                                            'outArgs': [],
                                            'returnInfo': {'doc': 'Name of this class.',
                                                           'qualifiers': ['*'],
                                                           'type': 'char'},
                                            'returnType': 'char',
                                            'static': True,
                                            'typeQualifiers': {},
                                            'types': {}}],
                             'deleteManipulator': [{'argInfo': {'manip': {'doc': 'the manipulator to be deleted',
                                                                          'type': 'MObject'}},
                                                    'args': [('manip',
                                                              'MObject',
                                                              'in')],
                                                    'defaults': {},
                                                    'deprecated': False,
                                                    'doc': 'Delete 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': 'This method returns the global option that says if the planar manipulator handles should be drawn or not.',
                                                   'inArgs': [],
                                                   'inverse': ('setDrawPlaneHandles',
                                                               False),
                                                   'outArgs': [],
                                                   'returnInfo': {'doc': 'True if the planar drag handles should be drawn.',
                                                                  'qualifiers': [],
                                                                  'type': 'bool'},
                                                   'returnType': 'bool',
                                                   'static': True,
                                                   'typeQualifiers': {},
                                                   'types': {}}],
                             'globalSize': [{'argInfo': {},
                                             'args': [],
                                             'defaults': {},
                                             'deprecated': False,
                                             'doc': 'Returns the global manipulator size.',
                                             'inArgs': [],
                                             'inverse': ('setGlobalSize',
                                                         False),
                                             'outArgs': [],
                                             'returnInfo': {'doc': 'The global manipulator size',
                                                            'qualifiers': [],
                                                            'type': 'float'},
                                             'returnType': 'float',
                                             'static': True,
                                             'typeQualifiers': {},
                                             'types': {}}],
                             'handleSize': [{'argInfo': {},
                                             'args': [],
                                             'defaults': {},
                                             'deprecated': False,
                                             'doc': 'Returns the manipulator handle size.',
                                             'inArgs': [],
                                             'inverse': ('setHandleSize',
                                                         False),
                                             'outArgs': [],
                                             'returnInfo': {'doc': 'The manipulator handle size',
                                                            'qualifiers': [],
                                                            'type': 'float'},
                                             'returnType': 'float',
                                             'static': True,
                                             'typeQualifiers': {},
                                             'types': {}}],
                             'isOptimizePlaybackOn': [{'argInfo': {},
                                                       'args': [],
                                                       'defaults': {},
                                                       'deprecated': False,
                                                       'doc': 'Returns 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': {},
                                                       'types': {}}],
                             'isVisible': [{'argInfo': {},
                                            'args': [],
                                            'defaults': {},
                                            'deprecated': False,
                                            'doc': 'Returns 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': {},
                                            'types': {}}],
                             'lineSize': [{'argInfo': {},
                                           'args': [],
                                           'defaults': {},
                                           'deprecated': False,
                                           'doc': 'Returns the manipulator line size.',
                                           'inArgs': [],
                                           'inverse': ('setLineSize', False),
                                           'outArgs': [],
                                           'returnInfo': {'doc': 'The manipulator line size',
                                                          'qualifiers': [],
                                                          'type': 'float'},
                                           'returnType': 'float',
                                           'static': True,
                                           'typeQualifiers': {},
                                           'types': {}}],
                             'manipScale': [{'argInfo': {},
                                             'args': [],
                                             'defaults': {},
                                             'deprecated': False,
                                             'doc': 'Returns the manipulator scale.',
                                             'inArgs': [],
                                             'inverse': ('setManipScale',
                                                         False),
                                             'outArgs': [],
                                             'returnInfo': {'doc': 'The manipulator scale',
                                                            'qualifiers': [],
                                                            'type': 'float'},
                                             'returnType': 'float',
                                             'static': False,
                                             'typeQualifiers': {},
                                             'types': {}}],
                             'rotateXYZValue': [{'argInfo': {'valIndex': {'doc': 'rotation index of the manipulator',
                                                                          'type': 'uint'}},
                                                 'args': [('valIndex',
                                                           'uint',
                                                           'in')],
                                                 'defaults': {},
                                                 'deprecated': False,
                                                 'doc': 'Gets 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': {'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': 'Sets 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': {},
                                                      'types': {'drawPlaneHandles': 'bool'}}],
                             'setGlobalSize': [{'argInfo': {'size': {'doc': 'the global manipulator size',
                                                                     'type': 'float'}},
                                                'args': [('size',
                                                          'float',
                                                          'in')],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': 'Sets the global manipulator size.',
                                                'inArgs': ['size'],
                                                'inverse': ('globalSize', True),
                                                'outArgs': [],
                                                'returnInfo': {'doc': '',
                                                               'qualifiers': [],
                                                               'type': None},
                                                'returnType': None,
                                                'static': True,
                                                'typeQualifiers': {},
                                                'types': {'size': 'float'}}],
                             'setHandleSize': [{'argInfo': {'size': {'doc': 'the manipulator handle size',
                                                                     'type': 'float'}},
                                                'args': [('size',
                                                          'float',
                                                          'in')],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': 'Sets the manipulator handle size.',
                                                'inArgs': ['size'],
                                                'inverse': ('handleSize', True),
                                                'outArgs': [],
                                                'returnInfo': {'doc': '',
                                                               'qualifiers': [],
                                                               'type': None},
                                                'returnType': None,
                                                'static': True,
                                                'typeQualifiers': {},
                                                'types': {'size': 'float'}}],
                             'setLineSize': [{'argInfo': {'size': {'doc': 'the manipulator line size',
                                                                   'type': 'float'}},
                                              'args': [('size', 'float', 'in')],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': 'Sets the manipulator line size.',
                                              'inArgs': ['size'],
                                              'inverse': ('lineSize', True),
                                              'outArgs': [],
                                              'returnInfo': {'doc': '',
                                                             'qualifiers': [],
                                                             'type': None},
                                              'returnType': None,
                                              'static': True,
                                              'typeQualifiers': {},
                                              'types': {'size': 'float'}}],
                             'setManipScale': [{'argInfo': {'size': {'doc': 'the manipulator scale',
                                                                     'type': 'float'}},
                                                'args': [('size',
                                                          'float',
                                                          'in')],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': 'Sets the manipulator scale.',
                                                'inArgs': ['size'],
                                                'inverse': ('manipScale', True),
                                                'outArgs': [],
                                                'returnInfo': {'doc': '',
                                                               'qualifiers': [],
                                                               'type': None},
                                                'returnType': None,
                                                'static': False,
                                                'typeQualifiers': {},
                                                'types': {'size': 'float'}}],
                             'setOptimizePlayback': [{'argInfo': {'optimizePlayback': {'doc': 'whether or not to optimize the playback',
                                                                                       'type': 'bool'}},
                                                      'args': [('optimizePlayback',
                                                                'bool',
                                                                'in')],
                                                      'defaults': {},
                                                      'deprecated': False,
                                                      'doc': 'Sets whether or not to optimize the playback',
                                                      'inArgs': ['optimizePlayback'],
                                                      'outArgs': [],
                                                      'returnInfo': {'doc': '',
                                                                     'qualifiers': [],
                                                                     'type': None},
                                                      'returnType': None,
                                                      'static': False,
                                                      'typeQualifiers': {},
                                                      'types': {'optimizePlayback': 'bool'}}],
                             'setVisible': [{'argInfo': {'isVisible': {'doc': 'whether or not the manipulator is visible',
                                                                       'type': 'bool'}},
                                             'args': [('isVisible',
                                                       'bool',
                                                       'out')],
                                             'defaults': {},
                                             'deprecated': False,
                                             'doc': 'Sets whether or not the manipulator is visible.',
                                             'inArgs': [],
                                             'inverse': ('isVisible', True),
                                             'outArgs': ['isVisible'],
                                             'returnInfo': {'doc': '',
                                                            'qualifiers': [],
                                                            'type': None},
                                             'returnType': None,
                                             'static': False,
                                             'typeQualifiers': {},
                                             'types': {'isVisible': 'bool'}}],
                             'type': [{'argInfo': {},
                                       'args': [],
                                       'defaults': {},
                                       'deprecated': False,
                                       'doc': 'Function set type',
                                       'inArgs': [],
                                       'outArgs': [],
                                       'returnInfo': {'doc': 'the class type.',
                                                      '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': {'array': [{'argInfo': {},
                                                'args': [],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': 'Get 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': {},
                                                'types': {}}],
                                     'className': [{'argInfo': {},
                                                    'args': [],
                                                    'defaults': {},
                                                    'deprecated': False,
                                                    'doc': 'Returns the name of this class.',
                                                    'inArgs': [],
                                                    'outArgs': [],
                                                    'returnInfo': {'doc': 'Name of this class.',
                                                                   'qualifiers': ['*'],
                                                                   'type': 'char'},
                                                    'returnType': 'char',
                                                    'static': True,
                                                    'typeQualifiers': {},
                                                    'types': {}}],
                                     'copyTo': [{'argInfo': {'dest': {'doc': 'the MMatrixArray to populate',
                                                                      'type': 'MMatrixArray'}},
                                                 'args': [('dest',
                                                           'MMatrixArray',
                                                           'out')],
                                                 'defaults': {},
                                                 'deprecated': False,
                                                 'doc': 'Copy 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': 'Create 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': {},
                                                 'types': {}},
                                                {'argInfo': {'arr': {'doc': 'the data to use when initializing this instance',
                                                                     'type': 'MMatrixArray'}},
                                                 'args': [('arr',
                                                           'MMatrixArray',
                                                           'in')],
                                                 'defaults': {},
                                                 'deprecated': False,
                                                 'doc': 'Create 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': {'arr': ['const',
                                                                            '&']},
                                                 'types': {'arr': 'MMatrixArray'}}],
                                     'length': [{'argInfo': {},
                                                 'args': [],
                                                 'defaults': {},
                                                 'deprecated': False,
                                                 'doc': 'Return the number of matrices in the instance.',
                                                 'inArgs': [],
                                                 'outArgs': [],
                                                 'returnInfo': {'doc': 'The number of matrices in the instance',
                                                                'qualifiers': [],
                                                                'type': 'uint'},
                                                 'returnType': 'uint',
                                                 'static': False,
                                                 'typeQualifiers': {},
                                                 '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': 'Set 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': 'Set 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': 'Function set type',
                                               'inArgs': [],
                                               'outArgs': [],
                                               'returnInfo': {'doc': 'the class type.',
                                                              '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': 'Returns the name of this class.',
                                                    'inArgs': [],
                                                    'outArgs': [],
                                                    'returnInfo': {'doc': 'Name of this class.',
                                                                   'qualifiers': ['*'],
                                                                   'type': 'char'},
                                                    'returnType': 'char',
                                                    'static': True,
                                                    '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': 'Creates 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': {'briefName': ['const',
                                                                                  '&'],
                                                                    'fullName': ['const',
                                                                                 '&']},
                                                 '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': 'Gets 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': 'Gets 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': 'Sets 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': 'Sets 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': 'Function set type',
                                               'inArgs': [],
                                               'outArgs': [],
                                               'returnInfo': {'doc': 'the class type.',
                                                              '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': 'Returns the name of this class.',
                                               'inArgs': [],
                                               'outArgs': [],
                                               'returnInfo': {'doc': 'Name of this class.',
                                                              'qualifiers': ['*'],
                                                              'type': 'char'},
                                               'returnType': 'char',
                                               'static': True,
                                               'typeQualifiers': {},
                                               'types': {}}],
                                'create': [{'argInfo': {},
                                            'args': [],
                                            'defaults': {},
                                            'deprecated': False,
                                            'doc': 'Create 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': {},
                                            'types': {}},
                                           {'argInfo': {'mat': {'doc': 'the MMatrix to copy the data from',
                                                                'type': 'MMatrix'}},
                                            'args': [('mat', 'MMatrix', 'in')],
                                            'defaults': {},
                                            'deprecated': False,
                                            'doc': 'Create 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': {'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': 'Create 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': {'transformation': ['const',
                                                                                  '&']},
                                            'types': {'transformation': 'MTransformationMatrix'}}],
                                'isTransformation': [{'argInfo': {},
                                                      'args': [],
                                                      'defaults': {},
                                                      'deprecated': False,
                                                      'doc': 'Determine 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': {},
                                                      'types': {}}],
                                'matrix': [{'argInfo': {},
                                            'args': [],
                                            'defaults': {},
                                            'deprecated': False,
                                            'doc': 'Return 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': {},
                                            'types': {}}],
                                'set': [{'argInfo': {'transformation': {'doc': 'the MTransformationMatrix matrix to copy the data from',
                                                                        'type': 'MTransformationMatrix'}},
                                         'args': [('transformation',
                                                   'MTransformationMatrix',
                                                   'in')],
                                         'defaults': {},
                                         'deprecated': False,
                                         'doc': 'Set 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': 'Set 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': 'Return 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': {},
                                                    'types': {}}],
                                'type': [{'argInfo': {},
                                          'args': [],
                                          'defaults': {},
                                          'deprecated': False,
                                          'doc': 'Function set type',
                                          'inArgs': [],
                                          'outArgs': [],
                                          'returnInfo': {'doc': 'the class type.',
                                                         '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.',
                                                         'kInternalPoint': 'Split at a point within a face.',
                                                         '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': [('setBinaryBlindData', 'getBinaryBlindData'),
                              ('setBoolBlindData', 'getBoolBlindData'),
                              ('setCheckSamePointTwice',
                               'getCheckSamePointTwice'),
                              ('setColor', 'getColor'),
                              ('setColors', 'getColors'),
                              ('setCreaseEdges', 'getCreaseEdges'),
                              ('setCreaseVertices', 'getCreaseVertices'),
                              ('setCurrentColorSetName', 'currentColorSetName'),
                              ('setCurrentUVSetName', 'currentUVSetName'),
                              ('setDisplayColors', 'displayColors'),
                              ('setDoubleBlindData', 'getDoubleBlindData'),
                              ('setFaceVertexColors', 'getFaceVertexColors'),
                              ('setFaceVertexNormal', 'getFaceVertexNormal'),
                              ('setFaceVertexNormals', 'getFaceVertexNormals'),
                              ('setFloatBlindData', 'getFloatBlindData'),
                              ('setIntBlindData', 'getIntBlindData'),
                              ('setInvisibleFaces', 'getInvisibleFaces'),
                              ('setIsColorClamped', 'isColorClamped'),
                              ('setNormals', 'getNormals'),
                              ('setPinUVs', 'getPinUVs'),
                              ('setPoint', 'getPoint'),
                              ('setPoints', 'getPoints'),
                              ('setSmoothMeshDisplayOptions',
                               'getSmoothMeshDisplayOptions'),
                              ('setStringBlindData', 'getStringBlindData'),
                              ('setUV', 'getUV'),
                              ('setUVs', 'getUVs'),
                              ('setVertexColors', 'getVertexColors'),
                              ('setVertexNormal', 'getVertexNormal'),
                              ('setVertexNormals', 'getVertexNormals')],
              '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': 'Adds holes to a mesh polygon.',
                                        'inArgs': ['faceIndex',
                                                   'vertexArray',
                                                   'loopCounts',
                                                   'mergeVertices',
                                                   'pointTolerance'],
                                        'outArgs': [],
                                        'returnInfo': {'doc': '',
                                                       'qualifiers': [],
                                                       'type': None},
                                        'returnType': None,
                                        'static': False,
                                        'typeQualifiers': {'loopCounts': ['const',
                                                                          '&'],
                                                           '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': 'Adds 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': {'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': 'Adds 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': {'faceIndex': ['&'],
                                                             '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': 'Adds 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': {'faceIndex': ['&'],
                                                             'loopCounts': ['const',
                                                                            '&'],
                                                             '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': 'Finds 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': {'accelParams': ['*'],
                                                                   'faceIds': ['const',
                                                                               '*'],
                                                                   'hitBary1s': ['*'],
                                                                   'hitBary2s': ['*'],
                                                                   'hitFaces': ['*'],
                                                                   'hitPoints': ['&'],
                                                                   'hitRayParams': ['*'],
                                                                   'hitTriangles': ['*'],
                                                                   'rayDirection': ['const',
                                                                                    '&'],
                                                                   'raySource': ['const',
                                                                                 '&'],
                                                                   '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': 'Finds 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': {'accelParams': ['*'],
                                                                  'faceIds': ['const',
                                                                              '*'],
                                                                  'hitBary1': ['*'],
                                                                  'hitBary2': ['*'],
                                                                  'hitFace': ['*'],
                                                                  'hitPoint': ['&'],
                                                                  'hitRayParam': ['*'],
                                                                  'hitTriangle': ['*'],
                                                                  'rayDirection': ['const',
                                                                                   '&'],
                                                                  'raySource': ['const',
                                                                                '&'],
                                                                  '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': 'Maps 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': {'colorSet': ['const',
                                                                           '*']},
                                           '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': 'This 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': 'Maps 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': {'uvSet': ['const',
                                                                     '*']},
                                        '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': 'This 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': 'Creates 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': 'Get 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': {},
                                                          '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': 'This method is obsolete. [as of Maya 2019]',
                                         'inArgs': ['op', 'mesh1', 'mesh2'],
                                         'outArgs': [],
                                         'returnInfo': {'doc': '',
                                                        'qualifiers': [],
                                                        'type': None},
                                         'returnType': None,
                                         'static': False,
                                         'typeQualifiers': {'mesh1': ['&'],
                                                            'mesh2': ['&']},
                                         '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': 'Computes 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',
                                                                        '&']},
                                          'types': {'meshes': 'MObjectArray',
                                                    'op': ('MFnMesh',
                                                           'BoolOperation'),
                                                    'useLegacy': 'bool'}}],
                          'cachedIntersectionAcceleratorInfo': [{'argInfo': {},
                                                                 'args': [],
                                                                 'defaults': {},
                                                                 'deprecated': False,
                                                                 'doc': 'Retrieves 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': {},
                                                                 'types': {}}],
                          'className': [{'argInfo': {},
                                         'args': [],
                                         'defaults': {},
                                         'deprecated': False,
                                         'doc': 'Returns the name of this class.',
                                         'inArgs': [],
                                         'outArgs': [],
                                         'returnInfo': {'doc': 'Name of this class.',
                                                        'qualifiers': ['*'],
                                                        'type': 'char'},
                                         'returnType': 'char',
                                         'static': True,
                                         'typeQualifiers': {},
                                         'types': {}}],
                          'cleanupEdgeSmoothing': [{'argInfo': {},
                                                    'args': [],
                                                    'defaults': {},
                                                    'deprecated': False,
                                                    'doc': "This 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': 'Delete 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': {},
                                              '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': 'Delete 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': {},
                                              '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': 'Delete 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': {},
                                              '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': 'Delete 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': {},
                                              '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': 'Delete 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': {},
                                              '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': 'This 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': 'As 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.',
                                                                      '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': 'This 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': 'Finds 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': {'accelParams': ['*'],
                                                                      'faceIds': ['const',
                                                                                  '*'],
                                                                      'hitBary1': ['*'],
                                                                      'hitBary2': ['*'],
                                                                      'hitFace': ['*'],
                                                                      'hitPoint': ['&'],
                                                                      'hitRayParam': ['*'],
                                                                      'hitTriangle': ['*'],
                                                                      'rayDirection': ['const',
                                                                                       '&'],
                                                                      'raySource': ['const',
                                                                                    '&'],
                                                                      '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': 'This 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': 'This 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': 'Get 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': 'Get 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': {},
                                                 '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': 'This 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': {'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': 'This 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': 'Copies 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': {'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': 'Creates 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': {'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': 'Creates 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': {'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': 'Creates 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': {'polygonConnects': ['const',
                                                                             '&'],
                                                         'polygonCounts': ['const',
                                                                           '&'],
                                                         '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': 'Creates 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': {'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': 'Creates 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': {'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': 'Creates 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': {'edgeConnectsCount': ['const',
                                                                               '&'],
                                                         'edgeFaceConnects': ['const',
                                                                              '&'],
                                                         'edgeFaceDesc': ['const',
                                                                          '&'],
                                                         'edges': ['const',
                                                                   '&'],
                                                         'vertexArray': ['const',
                                                                         '&']},
                                      'types': {'edgeConnectsCount': 'MIntArray',
                                                'edgeFaceConnects': 'MIntArray',
                                                'edgeFaceDesc': 'MIntArray',
                                                'edges': 'MIntArray',
                                                'parentOrOwner': 'MObject',
                                                'vertexArray': 'MFloatPointArray'}},
                                     {'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'},
                                                  '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': [('vertexArray',
                                                'MPointArray',
                                                'in'),
                                               ('edges', 'MIntArray', 'in'),
                                               ('edgeConnectsCount',
                                                'MIntArray',
                                                'in'),
                                               ('edgeFaceConnects',
                                                'MIntArray',
                                                'in'),
                                               ('edgeFaceDesc',
                                                'MIntArray',
                                                'in'),
                                               ('storeDoubles', 'bool', 'in'),
                                               ('parentOrOwner',
                                                'MObject',
                                                'in')],
                                      'defaults': {'parentOrOwner': 'MObject::kNullObj'},
                                      'deprecated': False,
                                      'doc': 'Creates 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',
                                                 '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': {'edgeConnectsCount': ['const',
                                                                               '&'],
                                                         'edgeFaceConnects': ['const',
                                                                              '&'],
                                                         'edgeFaceDesc': ['const',
                                                                          '&'],
                                                         'edges': ['const',
                                                                   '&'],
                                                         'vertexArray': ['const',
                                                                         '&']},
                                      'types': {'edgeConnectsCount': 'MIntArray',
                                                'edgeFaceConnects': 'MIntArray',
                                                'edgeFaceDesc': 'MIntArray',
                                                'edges': 'MIntArray',
                                                'parentOrOwner': 'MObject',
                                                'storeDoubles': 'bool',
                                                'vertexArray': 'MPointArray'}}],
                          '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': 'Create 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': {},
                                                   'types': {'blindDataId': 'int',
                                                             'formatNames': 'MStringArray',
                                                             'longNames': 'MStringArray',
                                                             'shortNames': 'MStringArray'}}],
                          'createColorSetDataMesh': [{'argInfo': {'clamped': {'doc': '',
                                                                              'type': 'bool'},
                                                                  'colorSetName': {'doc': '',
                                                                                   'type': 'MString'},
                                                                  'rep': {'doc': '',
                                                                          'type': ('MFnMesh',
                                                                                   'MColorRepresentation')}},
                                                      'args': [('colorSetName',
                                                                'MString',
                                                                'in'),
                                                               ('clamped',
                                                                'bool',
                                                                'in'),
                                                               ('rep',
                                                                ('MFnMesh',
                                                                 'MColorRepresentation'),
                                                                'in')],
                                                      'defaults': {'clamped': False,
                                                                   'rep': ('MFnMesh',
                                                                           'MColorRepresentation',
                                                                           'kRGBA')},
                                                      'deprecated': False,
                                                      'doc': '',
                                                      'inArgs': ['colorSetName',
                                                                 'clamped',
                                                                 'rep'],
                                                      'outArgs': [],
                                                      'returnInfo': {'doc': '',
                                                                     'qualifiers': [],
                                                                     'type': None},
                                                      'returnType': None,
                                                      'static': False,
                                                      'typeQualifiers': {'colorSetName': ['&']},
                                                      'types': {'clamped': 'bool',
                                                                'colorSetName': 'MString',
                                                                'rep': ('MFnMesh',
                                                                        'MColorRepresentation')}}],
                          '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': "Create 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': {'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': 'This method is obsolete. [as of Maya 2019]',
                                                      'inArgs': ['colorSetName',
                                                                 'modifier'],
                                                      'outArgs': [],
                                                      'returnInfo': {'doc': 'The resulting name of the color set.',
                                                                     'qualifiers': [],
                                                                     'type': 'MString'},
                                                      'returnType': 'MString',
                                                      'static': False,
                                                      'typeQualifiers': {'colorSetName': ['const',
                                                                                          '&'],
                                                                         'modifier': ['*']},
                                                      'types': {'colorSetName': 'MString',
                                                                'modifier': 'MDGModifier'}}],
                          'createColorSetWithNameDataMesh': [{'argInfo': {'clamped': {'doc': '',
                                                                                      'type': 'bool'},
                                                                          'colorSetName': {'doc': '',
                                                                                           'type': 'MString'},
                                                                          'rep': {'doc': '',
                                                                                  'type': ('MFnMesh',
                                                                                           'MColorRepresentation')}},
                                                              'args': [('colorSetName',
                                                                        'MString',
                                                                        'in'),
                                                                       ('clamped',
                                                                        'bool',
                                                                        'in'),
                                                                       ('rep',
                                                                        ('MFnMesh',
                                                                         'MColorRepresentation'),
                                                                        'in')],
                                                              'defaults': {},
                                                              'deprecated': False,
                                                              'doc': '',
                                                              'inArgs': ['colorSetName',
                                                                         'clamped',
                                                                         'rep'],
                                                              'outArgs': [],
                                                              'returnInfo': {'doc': '',
                                                                             'qualifiers': [],
                                                                             'type': 'MString'},
                                                              'returnType': 'MString',
                                                              'static': False,
                                                              'typeQualifiers': {'colorSetName': ['const',
                                                                                                  '&']},
                                                              'types': {'clamped': 'bool',
                                                                        'colorSetName': 'MString',
                                                                        'rep': ('MFnMesh',
                                                                                'MColorRepresentation')}}],
                          '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': 'Replaces 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': {'polygonConnects': ['const',
                                                                                    '&'],
                                                                'polygonCounts': ['const',
                                                                                  '&'],
                                                                'vertexArray': ['const',
                                                                                '&']},
                                             'types': {'numPolygons': 'int',
                                                       'numVertices': 'int',
                                                       'polygonConnects': 'MIntArray',
                                                       'polygonCounts': 'MIntArray',
                                                       'vertexArray': 'MFloatPointArray'}}],
                          'createUVSetDataMeshWithName': [{'argInfo': {'uvSetName': {'doc': '',
                                                                                     'type': 'MString'}},
                                                           'args': [('uvSetName',
                                                                     'MString',
                                                                     'in')],
                                                           'defaults': {},
                                                           'deprecated': False,
                                                           'doc': '',
                                                           'inArgs': ['uvSetName'],
                                                           'outArgs': [],
                                                           'returnInfo': {'doc': '',
                                                                          'qualifiers': [],
                                                                          'type': 'MString'},
                                                           'returnType': 'MString',
                                                           'static': False,
                                                           'typeQualifiers': {'uvSetName': ['const',
                                                                                            '&']},
                                                           'types': {'uvSetName': 'MString'}}],
                          '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': "Create 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': {'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': 'Get 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': {},
                                                   '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': 'Get 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': {},
                                                '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': 'Deletes 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': 'Delete this edge.',
                                          'inArgs': ['edgeId', 'modifier'],
                                          'outArgs': [],
                                          'returnInfo': {'doc': '',
                                                         'qualifiers': [],
                                                         'type': None},
                                          'returnType': None,
                                          'static': False,
                                          'typeQualifiers': {'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': 'Delete 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': {'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': 'Deletes 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': 'Delete this vertex.',
                                            'inArgs': ['vertexId', 'modifier'],
                                            'outArgs': [],
                                            'returnInfo': {'doc': '',
                                                           'qualifiers': [],
                                                           'type': None},
                                            'returnType': None,
                                            'static': False,
                                            'typeQualifiers': {'modifier': ['*']},
                                            'types': {'modifier': 'MDGModifier',
                                                      'vertexId': 'int'}}],
                          'displayColors': [{'argInfo': {},
                                             'args': [],
                                             'defaults': {},
                                             'deprecated': False,
                                             'doc': 'Determine 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': {},
                                             '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': 'This 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': 'This 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.0,
                                                         'thickness': 0.0},
                                            'deprecated': False,
                                            'doc': 'This 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': ['&'],
                                                               '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.0,
                                                         'thickness': 0.0},
                                            'deprecated': False,
                                            'doc': 'This 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': {'faceList': ['&'],
                                                               'translation': ['*']},
                                            'types': {'extrudeTogether': 'bool',
                                                      'extrusionCount': 'int',
                                                      'faceList': 'MIntArray',
                                                      'offset': 'float',
                                                      'thickness': 'float',
                                                      'translation': 'MFloatVector'}}],
                          'freeCachedIntersectionAccelerator': [{'argInfo': {},
                                                                 'args': [],
                                                                 'defaults': {},
                                                                 'deprecated': False,
                                                                 'doc': 'If 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': 'Creates 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': {'options': ['*']},
                                                  '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': 'This method is obsolete. [as of Maya 2019]',
                                                  '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': {},
                                                  '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': 'Get 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': 'Get 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': 'Get 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': 'Get 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': 'Find 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': ['&'],
                                                                 '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': 'Get 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': {'compIDs': ['&'],
                                                                     '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': 'Return the binormal vectors for all face vertices.',
                                            'inArgs': ['space', 'uvSet'],
                                            'outArgs': ['binormals'],
                                            'returnInfo': {'doc': '',
                                                           'qualifiers': [],
                                                           'type': None},
                                            'returnType': None,
                                            'static': False,
                                            'typeQualifiers': {'binormals': ['&'],
                                                               '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': 'Get 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': {'formatNames': ['&'],
                                                                        'longNames': ['&'],
                                                                        'shortNames': ['&']},
                                                     'types': {'blindDataId': 'int',
                                                               'formatNames': 'MStringArray',
                                                               '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': 'Get 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': {'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': "Get 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': ['&']},
                                                 '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': 'Get 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': {'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': 'Get 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': {'compIDs': ['&'],
                                                                   'data': ['&']},
                                                'types': {'attrName': 'MString',
                                                          'blindDataId': 'int',
                                                          'compIDs': 'MIntArray',
                                                          'compType': ('MFn',
                                                                       'Type'),
                                                          'data': 'MIntArray'}}],
                          'getCheckSamePointTwice': [{'argInfo': {},
                                                      'args': [],
                                                      'defaults': {},
                                                      'deprecated': False,
                                                      'doc': 'Return true if checking for duplicate points is turned on. Return false otherwise.',
                                                      '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': 'Returns 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': ['*'],
                                                                   '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': 'Returns 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': ['*'],
                                                                  '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': 'Returns 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': ['*'],
                                                                           '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': 'Returns 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': "Get 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': ['&'],
                                                           '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': 'Get 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',
                                                                             '*']},
                                             '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': 'This 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': {'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': 'Get 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': 'Get 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': 'Get 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': 'This 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': 'Returns 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': 'This 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': 'This 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': 'Get 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': {'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': 'Get 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': {'compIDs': ['&'],
                                                                     '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': "This 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': {'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': 'Return 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': {'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': 'This 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': {'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': 'Return 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': ['&'],
                                                                        'uvSet': ['const',
                                                                                  '*']},
                                                     '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': 'Return 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': ['&'],
                                                                         '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': 'Get 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': ['&']},
                                                           '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': 'Get 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',
                                                                                       '*']},
                                                       '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': 'Get 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': 'Return 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': {'normal': ['&']},
                                                   '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': 'Return 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': {'normals': ['&']},
                                                    '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': 'Return 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': {'tangent': ['&'],
                                                                       'uvSet': ['const',
                                                                                 '*']},
                                                    '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': 'Return 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': {'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': 'Get 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': {'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': 'Get 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': {'compIDs': ['&'],
                                                                    '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': 'Retrieves 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': {'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': 'Get 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': {'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': 'Get 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': {'compIDs': ['&'],
                                                                  'data': ['&']},
                                               'types': {'attrName': 'MString',
                                                         'blindDataId': 'int',
                                                         'compIDs': 'MIntArray',
                                                         'compType': ('MFn',
                                                                      'Type'),
                                                         'data': 'MIntArray'}}],
                          'getInvisibleFaces': [{'argInfo': {},
                                                 'args': [],
                                                 'defaults': {},
                                                 'deprecated': False,
                                                 'doc': 'This 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': {},
                                                 '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': 'Get normal indices for all vertices of 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': 'This 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': ['&']},
                                          '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': 'This 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': "Get 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': ['&']},
                                        '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': 'Return 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': {'toThisPoint': ['&'],
                                                               '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': 'This 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': {'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': 'This 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': {'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': 'Return 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': ['&'],
                                                                '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': 'Return 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': ['&']},
                                                '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': "This 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': {},
                                                          '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': "Get 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': {'u': ['&'],
                                                               'uvSet': ['const',
                                                                         '*'],
                                                               'v': ['&']},
                                            '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': 'Get 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': {'uvId': ['&'],
                                                                 'uvSet': ['const',
                                                                           '*']},
                                              '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': "This 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': {'vertexList': ['&']},
                                                  'types': {'polygonId': 'int',
                                                            'vertexList': 'MIntArray'}}],
                          'getRawDoublePoints': [{'argInfo': {},
                                                  'args': [],
                                                  'defaults': {},
                                                  'deprecated': False,
                                                  'doc': 'This method returns a pointer to the internal vertex list for this mesh. The points are in local space.',
                                                  'inArgs': [],
                                                  'outArgs': [],
                                                  'returnInfo': {'doc': 'Pointer to internal vertex list data structure',
                                                                 'qualifiers': ['*'],
                                                                 'type': 'double'},
                                                  'returnType': 'double',
                                                  'static': False,
                                                  'typeQualifiers': {},
                                                  'types': {}}],
                          'getRawNormals': [{'argInfo': {},
                                             'args': [],
                                             'defaults': {},
                                             'deprecated': False,
                                             'doc': 'This 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': 'Pointer to internal per-polygon per-vertex normal data structure',
                                                            'qualifiers': ['*'],
                                                            'type': 'float'},
                                             'returnType': 'float',
                                             'static': False,
                                             'typeQualifiers': {},
                                             'types': {}}],
                          'getRawPoints': [{'argInfo': {},
                                            'args': [],
                                            'defaults': {},
                                            'deprecated': False,
                                            'doc': 'This method returns a pointer to the internal vertex list for this mesh. The points are in local space.',
                                            'inArgs': [],
                                            'outArgs': [],
                                            'returnInfo': {'doc': 'Pointer to internal vertex list data structure',
                                                           'qualifiers': ['*'],
                                                           'type': 'float'},
                                            'returnType': 'float',
                                            'static': False,
                                            'typeQualifiers': {},
                                            'types': {}}],
                          'getSmoothMeshDisplayOptions': [{'argInfo': {'options': {'doc': 'storge for the options',
                                                                                   'type': 'MMeshSmoothOptions'}},
                                                           'args': [('options',
                                                                     'MMeshSmoothOptions',
                                                                     'out')],
                                                           'defaults': {},
                                                           'deprecated': False,
                                                           'doc': 'Retrieve 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': 'Get 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': {'compIDs': ['&'],
                                                                     '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': 'Return the tangent index for a given face vertex.',
                                            'inArgs': ['faceIndex',
                                                       'vertexIndex'],
                                            'outArgs': [],
                                            'returnInfo': {'doc': '',
                                                           'qualifiers': [],
                                                           'type': 'int'},
                                            'returnType': 'int',
                                            'static': False,
                                            'typeQualifiers': {},
                                            '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': 'Return 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': {'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': 'Returns 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': 'Returns 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': "Get 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': ['&'],
                                                        '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': 'Find 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': ['&'],
                                                               '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': 'Get 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': 'Get 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': 'Get 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': 'This 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': 'Constructs 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': 'Get 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': 'This method is obsolete. [as of Maya 2019]',
                                               'inArgs': ['vertexId', 'space'],
                                               'inverse': ('setVertexNormal',
                                                           False),
                                               'outArgs': ['normal'],
                                               'returnInfo': {'doc': '',
                                                              'qualifiers': [],
                                                              'type': None},
                                               'returnType': None,
                                               'static': False,
                                               'typeQualifiers': {'normal': ['&']},
                                               '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': 'Return 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': {'normal': ['&']},
                                               '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': 'Return 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': {'normals': ['&']},
                                                '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': "This 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': 'Retrieves a string that describes the systemwide resource usage for cached mesh intersection accelerators. The string will be formatted similar to:',
                                                                  'inArgs': [],
                                                                  'outArgs': [],
                                                                  'returnInfo': {'doc': 'The information string',
                                                                                 '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': 'This 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': {'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': 'Returns 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': {},
                                            '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': 'Does 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': {},
                                            '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': 'Does 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': {},
                                                       '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': 'Does 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': {},
                                                       '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': 'This 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': {'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': 'Determines 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': {'points': ['&'],
                                                            'polygonIds': ['*'],
                                                            'rayDirection': ['const',
                                                                             '&'],
                                                            'raySource': ['const',
                                                                          '&']},
                                         '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': 'Returns 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': 'Is 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': {},
                                                   'types': {'blindDataId': 'int'}}],
                          'isColorClamped': [{'argInfo': {'colorSet': {'doc': 'Color set to work with',
                                                                       'type': 'MString'}},
                                              'args': [('colorSet',
                                                        'MString',
                                                        'in')],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': 'This 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': {'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': 'Return 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': {'name': ['const',
                                                                                 '&']},
                                                     'types': {'name': 'MString'}}],
                          'isEdgeSmooth': [{'argInfo': {'edgeId': {'doc': 'The edge to be tested',
                                                                   'type': 'int'}},
                                            'args': [('edgeId', 'int', 'in')],
                                            'defaults': {},
                                            'deprecated': False,
                                            'doc': 'This 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': {},
                                            'types': {'edgeId': 'int'}}],
                          'isNormalLocked': [{'argInfo': {'normalId': {'doc': 'Normal to test.',
                                                                       'type': 'int'}},
                                              'args': [('normalId',
                                                        'int',
                                                        'in')],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': 'Test 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': {},
                                              'types': {'normalId': 'int'}}],
                          'isPolygonConvex': [{'argInfo': {'faceIndex': {'doc': 'The polygon to be tested',
                                                                         'type': 'int'}},
                                               'args': [('faceIndex',
                                                         'int',
                                                         'in')],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': 'This 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': {},
                                               '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': "This 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': {'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': 'Returns 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': {'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': 'Return 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': {'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': 'Lock 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': 'Lock 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': 'Returns 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': {},
                                            'types': {}}],
                          'numColors': [{'argInfo': {},
                                         'args': [],
                                         'defaults': {},
                                         'deprecated': False,
                                         'doc': 'Returns 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': {},
                                         'types': {}},
                                        {'argInfo': {'colorSet': {'doc': 'Color set to work with',
                                                                  'type': 'MString'}},
                                         'args': [('colorSet',
                                                   'MString',
                                                   'in')],
                                         'defaults': {},
                                         'deprecated': False,
                                         'doc': 'Returns 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': {'colorSet': ['const',
                                                                         '&']},
                                         'types': {'colorSet': 'MString'}}],
                          'numEdges': [{'argInfo': {},
                                        'args': [],
                                        'defaults': {},
                                        'deprecated': False,
                                        'doc': 'Returns 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': {},
                                        'types': {}}],
                          'numFaceVertices': [{'argInfo': {},
                                               'args': [],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': 'Returns 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': {},
                                               'types': {}}],
                          'numNormals': [{'argInfo': {},
                                          'args': [],
                                          'defaults': {},
                                          'deprecated': False,
                                          'doc': 'Returns 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': {},
                                          'types': {}}],
                          'numPolygons': [{'argInfo': {},
                                           'args': [],
                                           'defaults': {},
                                           'deprecated': False,
                                           'doc': 'Returns 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': {},
                                           'types': {}}],
                          'numUVSets': [{'argInfo': {},
                                         'args': [],
                                         'defaults': {},
                                         'deprecated': False,
                                         'doc': 'Returns 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': {},
                                         'types': {}}],
                          'numUVs': [{'argInfo': {},
                                      'args': [],
                                      'defaults': {},
                                      'deprecated': False,
                                      'doc': "Returns 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': {},
                                      'types': {}},
                                     {'argInfo': {'uvSet': {'doc': 'UV set to work with',
                                                            'type': 'MString'}},
                                      'args': [('uvSet', 'MString', 'in')],
                                      'defaults': {},
                                      'deprecated': False,
                                      'doc': "Returns 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': {'uvSet': ['const',
                                                                   '&']},
                                      'types': {'uvSet': 'MString'}}],
                          'numVertices': [{'argInfo': {},
                                           'args': [],
                                           'defaults': {},
                                           'deprecated': False,
                                           'doc': 'Returns 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': {},
                                           'types': {}}],
                          'objectChanged': [{'argInfo': {'tp': {'doc': '',
                                                                'type': ('MFn',
                                                                         'Type')}},
                                             'args': [('tp',
                                                       ('MFn', 'Type'),
                                                       'in')],
                                             'defaults': {},
                                             'deprecated': False,
                                             'doc': '',
                                             'inArgs': ['tp'],
                                             'outArgs': [],
                                             'returnInfo': {'doc': '',
                                                            'qualifiers': [],
                                                            'type': 'bool'},
                                             'returnType': 'bool',
                                             'static': False,
                                             'typeQualifiers': {},
                                             'types': {'tp': ('MFn', 'Type')}}],
                          'onBoundary': [{'argInfo': {'polygonId': {'doc': 'The polygon (face) to examine',
                                                                    'type': 'int'}},
                                          'args': [('polygonId', 'int', 'in')],
                                          'defaults': {},
                                          'deprecated': False,
                                          'doc': 'A 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': {},
                                          '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': 'Triangulates 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': {'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': 'Triangulates 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': 'Returns 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': {},
                                                  'types': {'polygonId': 'int'}}],
                          'removeFaceColors': [{'argInfo': {'faceList': {'doc': 'The faces to remove color from',
                                                                         'type': 'MIntArray'}},
                                                'args': [('faceList',
                                                          'MIntArray',
                                                          'in')],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': 'Remove 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': 'Remove 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': 'Remove 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': 'Renames 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': 'Set 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': {},
                                                  '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': 'Set 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': {'compIDs': ['&']},
                                                  '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': 'Set 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': {'compIDs': ['&'],
                                                                     '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': 'Set 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': {'data': ['*']},
                                                  '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': 'Set 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': {},
                                                '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': 'Set 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': {'compIDs': ['&']},
                                                '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': 'Set 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': {'compIDs': ['&'],
                                                                   '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': 'This 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': {},
                                                      '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': 'Sets 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',
                                                                     '&'],
                                                           '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': 'Sets 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',
                                                                     '&'],
                                                           'colorSet': ['const',
                                                                        '*']},
                                        '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': 'Sets 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': 'Sets 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',
                                                                         '*']},
                                         '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': 'This 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': 'This 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': 'Set 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': 'Set 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': 'Set whether the mesh node should display vertex colors.',
                                                'inArgs': ['enable'],
                                                'inverse': ('displayColors',
                                                            True),
                                                'outArgs': [],
                                                'returnInfo': {'doc': '',
                                                               'qualifiers': [],
                                                               'type': None},
                                                'returnType': None,
                                                'static': False,
                                                'typeQualifiers': {},
                                                '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': 'Set 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': {},
                                                  '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': 'Set 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': {'compIDs': ['&']},
                                                  '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': 'Set 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': {'compIDs': ['&'],
                                                                     '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': 'This 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': {},
                                                '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': 'This 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': 'Set vertex-face Color for all vertices on this face.',
                                            'inArgs': ['color', 'faceIndex'],
                                            'outArgs': [],
                                            'returnInfo': {'doc': '',
                                                           'qualifiers': [],
                                                           'type': None},
                                            'returnType': None,
                                            'static': False,
                                            'typeQualifiers': {'color': ['&']},
                                            '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': 'Set 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': ['&']},
                                            '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': 'Set 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': 'Set 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': ['&']},
                                             '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': 'Set color for this vertex in this face.',
                                                  'inArgs': ['color',
                                                             'faceIndex',
                                                             'vertexIndex',
                                                             'modifier'],
                                                  'outArgs': [],
                                                  'returnInfo': {'doc': '',
                                                                 'qualifiers': [],
                                                                 'type': None},
                                                  'returnType': None,
                                                  'static': False,
                                                  'typeQualifiers': {'color': ['&'],
                                                                     'modifier': ['*']},
                                                  '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': 'Set 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': ['&'],
                                                                     'modifier': ['*']},
                                                  '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': 'Set color for this vertex in this face.',
                                                  'inArgs': ['faceIndex',
                                                             'localVertexIndex',
                                                             'color',
                                                             'modifier'],
                                                  'outArgs': [],
                                                  'returnInfo': {'doc': '',
                                                                 'qualifiers': [],
                                                                 'type': None},
                                                  'returnType': None,
                                                  'static': False,
                                                  'typeQualifiers': {'color': ['&'],
                                                                     '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': 'Set 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': ['&'],
                                                                     'modifier': ['*']},
                                                  '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': 'Set 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': 'Set 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': ['*'],
                                                                      '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': 'Set 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': {'modifier': ['*'],
                                                                      'normalIn': ['&']},
                                                   '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': 'Set 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': ['&'],
                                                                       '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': 'Set 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': {},
                                                 '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': 'Set 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': {'compIDs': ['&']},
                                                 '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': 'Set 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': {'compIDs': ['&'],
                                                                    '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': 'Set 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': {},
                                               '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': 'Set 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': {'compIDs': ['&']},
                                               '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': 'Set 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': {'compIDs': ['&'],
                                                                  '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': 'This 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',
                                                                                '&']},
                                                 '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': 'Set the color set to be clamped.',
                                                 'inArgs': ['colorSet',
                                                            'clamped'],
                                                 'inverse': ('isColorClamped',
                                                             True),
                                                 'outArgs': [],
                                                 'returnInfo': {'doc': '',
                                                                'qualifiers': [],
                                                                'type': None},
                                                 'returnType': None,
                                                 'static': False,
                                                 'typeQualifiers': {'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': 'Set the normal array (user normals)',
                                          'inArgs': ['normals', 'space'],
                                          'inverse': ('getNormals', True),
                                          'outArgs': [],
                                          'returnInfo': {'doc': '',
                                                         'qualifiers': [],
                                                         'type': None},
                                          'returnType': None,
                                          'static': False,
                                          'typeQualifiers': {'normals': ['&']},
                                          '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': 'This 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': 'Sets 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',
                                                                   '&']},
                                        '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': [('vertexArray',
                                                   'MFloatPointArray',
                                                   'in'),
                                                  ('space',
                                                   ('MSpace', 'Space'),
                                                   'in')],
                                         'defaults': {'space': ('MSpace',
                                                                'Space',
                                                                'kObject')},
                                         'deprecated': False,
                                         'doc': 'This method copies the points in the given point array to the vertices of this polygon.',
                                         'inArgs': ['vertexArray', 'space'],
                                         'inverse': ('getPoints', True),
                                         'outArgs': [],
                                         'returnInfo': {'doc': '',
                                                        'qualifiers': [],
                                                        'type': None},
                                         'returnType': None,
                                         'static': False,
                                         'typeQualifiers': {'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',
                                                   'in'),
                                                  ('space',
                                                   ('MSpace', 'Space'),
                                                   'in')],
                                         'defaults': {'space': ('MSpace',
                                                                'Space',
                                                                'kObject')},
                                         'deprecated': False,
                                         'doc': 'This method copies the points in the given point array to the vertices of this mesh.',
                                         'inArgs': ['vertexArray', 'space'],
                                         'inverse': ('getPoints', True),
                                         'outArgs': [],
                                         'returnInfo': {'doc': '',
                                                        'qualifiers': [],
                                                        'type': None},
                                         'returnType': None,
                                         'static': False,
                                         'typeQualifiers': {'vertexArray': ['&']},
                                         'types': {'space': ('MSpace', 'Space'),
                                                   'vertexArray': 'MPointArray'}}],
                          'setSmoothMeshDisplayOptions': [{'argInfo': {'options': {'doc': 'Options to set',
                                                                                   'type': 'MMeshSmoothOptions'}},
                                                           'args': [('options',
                                                                     'MMeshSmoothOptions',
                                                                     'in')],
                                                           'defaults': {},
                                                           'deprecated': False,
                                                           'doc': 'Sets 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': 'Sets 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': 'Sets 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',
                                                                             '*']},
                                             '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': "Sets 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': 'Set 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': {},
                                                  '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': 'Set 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': {'compIDs': ['&']},
                                                  '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': 'Set 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': {'compIDs': ['&'],
                                                                     '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': 'Sets 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': {'uvSet': ['const',
                                                                  '*']},
                                     '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': "Sets 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': 'Set 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': ['*']},
                                              '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': 'Set 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': ['*']},
                                              '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': 'Set 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': 'Set 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': ['*'],
                                                                  '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': 'Set 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': ['&']},
                                               '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': 'Set 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': ['&'],
                                                                   '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': 'Convenience 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': 'This 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': 'Get 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': {},
                                                          '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': 'This 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': {'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': 'This 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': {'faceList': ['&']},
                                              'types': {'divisionCount': 'int',
                                                        'faceList': 'MIntArray'}}],
                          'syncObject': [{'argInfo': {},
                                          'args': [],
                                          'defaults': {},
                                          'deprecated': False,
                                          'doc': 'If 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': 'Function set type',
                                    'inArgs': [],
                                    'outArgs': [],
                                    'returnInfo': {'doc': 'the class type.',
                                                   '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': 'Creates 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': {},
                                                 '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': 'Unlock 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': 'Unlock 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': 'Signal 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': 'Returns the name of this class.',
                                             'inArgs': [],
                                             'outArgs': [],
                                             'returnInfo': {'doc': 'Name of this class.',
                                                            'qualifiers': ['*'],
                                                            'type': 'char'},
                                             'returnType': 'char',
                                             'static': True,
                                             'typeQualifiers': {},
                                             'types': {}}],
                              'create': [{'argInfo': {},
                                          'args': [],
                                          'defaults': {},
                                          'deprecated': False,
                                          'doc': 'Create 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': {},
                                          'types': {}}],
                              'type': [{'argInfo': {},
                                        'args': [],
                                        'defaults': {},
                                        'deprecated': False,
                                        'doc': 'Function set type',
                                        'inArgs': [],
                                        'outArgs': [],
                                        'returnInfo': {'doc': 'the class type.',
                                                       'qualifiers': [],
                                                       'type': ('MFn', 'Type')},
                                        'returnType': ('MFn', 'Type'),
                                        'static': False,
                                        'typeQualifiers': {},
                                        'types': {}}]},
                  'pymelEnums': {}},
  'MFnMessageAttribute': {'enums': {},
                          'methods': {'className': [{'argInfo': {},
                                                     'args': [],
                                                     'defaults': {},
                                                     'deprecated': False,
                                                     'doc': 'Returns the name of this class.',
                                                     'inArgs': [],
                                                     'outArgs': [],
                                                     'returnInfo': {'doc': 'Name of this class.',
                                                                    'qualifiers': ['*'],
                                                                    'type': 'char'},
                                                     'returnType': 'char',
                                                     'static': True,
                                                     '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': 'Creates a Message attribute object.',
                                                  'inArgs': ['fullName',
                                                             'briefName'],
                                                  'outArgs': [],
                                                  'returnInfo': {'doc': 'The newly created Message attribute object.',
                                                                 'qualifiers': [],
                                                                 'type': 'MObject'},
                                                  'returnType': 'MObject',
                                                  'static': False,
                                                  'typeQualifiers': {'briefName': ['const',
                                                                                   '&'],
                                                                     'fullName': ['const',
                                                                                  '&']},
                                                  'types': {'briefName': 'MString',
                                                            'fullName': 'MString'}}],
                                      'type': [{'argInfo': {},
                                                'args': [],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': 'Function set type',
                                                'inArgs': [],
                                                'outArgs': [],
                                                'returnInfo': {'doc': 'the class type.',
                                                               'qualifiers': [],
                                                               'type': ('MFn',
                                                                        'Type')},
                                                'returnType': ('MFn', 'Type'),
                                                'static': False,
                                                'typeQualifiers': {},
                                                'types': {}}]},
                          'pymelEnums': {}},
  'MFnMotionPath': {'enums': {'Axis': {'valueDocs': {},
                                       'values': "Enum('Axis', {'kXaxis': 0, 'kYaxis': 1, 'kZaxis': 2})"}},
                    'invertibles': [('setBank', 'bank'),
                                    ('setBankScale', 'bankScale'),
                                    ('setBankThreshold', 'bankThreshold'),
                                    ('setFollow', 'follow'),
                                    ('setFollowAxis', 'followAxis'),
                                    ('setInverseNormal', 'inverseNormal'),
                                    ('setPathObject', 'pathObject'),
                                    ('setUEnd', 'uEnd'),
                                    ('setUStart', 'uStart'),
                                    ('setUTimeEnd', 'uTimeEnd'),
                                    ('setUTimeStart', 'uTimeStart'),
                                    ('setUpAxis', 'upAxis'),
                                    ('setUseNormal', 'useNormal')],
                    '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': 'Add 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': 'Determines 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': {},
                                          'types': {}}],
                                'bankScale': [{'argInfo': {},
                                               'args': [],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': 'Return 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': {},
                                               'types': {}}],
                                'bankThreshold': [{'argInfo': {},
                                                   'args': [],
                                                   'defaults': {},
                                                   'deprecated': False,
                                                   'doc': 'Return 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': {},
                                                   'types': {}}],
                                'className': [{'argInfo': {},
                                               'args': [],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': 'Returns the name of this class.',
                                               'inArgs': [],
                                               'outArgs': [],
                                               'returnInfo': {'doc': 'Name of this class.',
                                                              'qualifiers': ['*'],
                                                              'type': 'char'},
                                               'returnType': 'char',
                                               'static': True,
                                               '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': 'Create 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': {'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': 'Determines 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': {},
                                            'types': {}}],
                                'followAxis': [{'argInfo': {},
                                                'args': [],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': 'Return 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': {},
                                                'types': {}}],
                                'getAnimatedObjects': [{'argInfo': {'array': {'doc': 'Storage for the dag paths.',
                                                                              'type': 'MDagPathArray'}},
                                                        'args': [('array',
                                                                  'MDagPathArray',
                                                                  'out')],
                                                        'defaults': {},
                                                        'deprecated': False,
                                                        'doc': 'Returns 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': 'Gets 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': {'markerNum': ['unsigned']},
                                                          'types': {'markerNum': 'uint'}}],
                                'getPositionMarker': [{'argInfo': {'markerNum': {'doc': 'The number of the marker',
                                                                                 'type': 'uint'}},
                                                       'args': [('markerNum',
                                                                 'uint',
                                                                 'in')],
                                                       'defaults': {},
                                                       'deprecated': False,
                                                       'doc': 'Gets 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': {'markerNum': ['unsigned']},
                                                       'types': {'markerNum': 'uint'}}],
                                'inverseNormal': [{'argInfo': {},
                                                   'args': [],
                                                   'defaults': {},
                                                   'deprecated': False,
                                                   'doc': 'Determines 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': {},
                                                   'types': {}}],
                                'numOrientationMarkers': [{'argInfo': {},
                                                           'args': [],
                                                           'defaults': {},
                                                           'deprecated': False,
                                                           'doc': 'Returns the number of orientation markers on this motion path.',
                                                           'inArgs': [],
                                                           'outArgs': [],
                                                           'returnInfo': {'doc': 'The number of markers',
                                                                          'qualifiers': [],
                                                                          'type': 'uint'},
                                                           'returnType': 'uint',
                                                           'static': False,
                                                           'typeQualifiers': {},
                                                           'types': {}}],
                                'numPositionMarkers': [{'argInfo': {},
                                                        'args': [],
                                                        'defaults': {},
                                                        'deprecated': False,
                                                        'doc': 'Returns the number of position markers on this motion path.',
                                                        'inArgs': [],
                                                        'outArgs': [],
                                                        'returnInfo': {'doc': 'The number of markers',
                                                                       'qualifiers': [],
                                                                       'type': 'uint'},
                                                        'returnType': 'uint',
                                                        'static': False,
                                                        'typeQualifiers': {},
                                                        'types': {}}],
                                'pathObject': [{'argInfo': {},
                                                'args': [],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': 'Return 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': {},
                                                'types': {}}],
                                'setBank': [{'argInfo': {'bank': {'doc': 'Specifies whether bank is turned on',
                                                                  'type': 'bool'}},
                                             'args': [('bank', 'bool', 'in')],
                                             'defaults': {},
                                             'deprecated': False,
                                             'doc': 'bank',
                                             'inArgs': ['bank'],
                                             'inverse': ('bank', True),
                                             'outArgs': [],
                                             'returnInfo': {'doc': '',
                                                            'qualifiers': [],
                                                            'type': None},
                                             'returnType': None,
                                             'static': False,
                                             'typeQualifiers': {},
                                             'types': {'bank': 'bool'}}],
                                'setBankScale': [{'argInfo': {'bankScale': {'doc': 'The new bank scale value',
                                                                            'type': 'double'}},
                                                  'args': [('bankScale',
                                                            'double',
                                                            'in')],
                                                  'defaults': {},
                                                  'deprecated': False,
                                                  'doc': 'Set 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': {},
                                                  'types': {'bankScale': 'double'}}],
                                'setBankThreshold': [{'argInfo': {'bankThreshold': {'doc': 'The new bank threshold value',
                                                                                    'type': 'double'}},
                                                      'args': [('bankThreshold',
                                                                'double',
                                                                'in')],
                                                      'defaults': {},
                                                      'deprecated': False,
                                                      'doc': 'Set 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': {},
                                                      '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': 'Setting 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': ['*']},
                                               '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': 'Sets 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': {},
                                                   'types': {'axis': ('MFnMotionPath',
                                                                      'Axis')}}],
                                'setInverseNormal': [{'argInfo': {'invert': {'doc': 'Specifies if inverse normal is used',
                                                                             'type': 'bool'}},
                                                      'args': [('invert',
                                                                'bool',
                                                                'in')],
                                                      'defaults': {},
                                                      'deprecated': False,
                                                      'doc': 'If 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': {},
                                                      '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': 'Set 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': 'Sets 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': {},
                                             'types': {'end': 'double'}}],
                                'setUStart': [{'argInfo': {'start': {'doc': 'the new start value',
                                                                     'type': 'double'}},
                                               'args': [('start',
                                                         'double',
                                                         'in')],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': 'Sets 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': {},
                                               'types': {'start': 'double'}}],
                                'setUTimeEnd': [{'argInfo': {'end': {'doc': 'the new end time',
                                                                     'type': 'MTime'}},
                                                 'args': [('end',
                                                           'MTime',
                                                           'in')],
                                                 'defaults': {},
                                                 'deprecated': False,
                                                 'doc': 'Sets 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': 'Sets 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': 'Set the up-axis for this motion path.',
                                               'inArgs': ['axis'],
                                               'inverse': ('upAxis', True),
                                               'outArgs': [],
                                               'returnInfo': {'doc': '',
                                                              'qualifiers': [],
                                                              'type': None},
                                               'returnType': None,
                                               'static': False,
                                               'typeQualifiers': {},
                                               'types': {'axis': ('MFnMotionPath',
                                                                  'Axis')}}],
                                'setUseNormal': [{'argInfo': {'use': {'doc': 'Specifies if normal is used',
                                                                      'type': 'bool'}},
                                                  'args': [('use',
                                                            'bool',
                                                            'in')],
                                                  'defaults': {},
                                                  'deprecated': False,
                                                  'doc': 'If 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': {},
                                                  'types': {'use': 'bool'}}],
                                'type': [{'argInfo': {},
                                          'args': [],
                                          'defaults': {},
                                          'deprecated': False,
                                          'doc': 'Function set type',
                                          'inArgs': [],
                                          'outArgs': [],
                                          'returnInfo': {'doc': 'the class type.',
                                                         'qualifiers': [],
                                                         'type': ('MFn',
                                                                  'Type')},
                                          'returnType': ('MFn', 'Type'),
                                          'static': False,
                                          'typeQualifiers': {},
                                          'types': {}}],
                                'uEnd': [{'argInfo': {},
                                          'args': [],
                                          'defaults': {},
                                          'deprecated': False,
                                          'doc': 'Returns 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': {},
                                          'types': {}}],
                                'uStart': [{'argInfo': {},
                                            'args': [],
                                            'defaults': {},
                                            'deprecated': False,
                                            'doc': 'Returns 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': {},
                                            'types': {}}],
                                'uTimeEnd': [{'argInfo': {},
                                              'args': [],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': 'Returns 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': {},
                                              'types': {}}],
                                'uTimeStart': [{'argInfo': {},
                                                'args': [],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': 'Returns 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': {},
                                                'types': {}}],
                                'upAxis': [{'argInfo': {},
                                            'args': [],
                                            'defaults': {},
                                            'deprecated': False,
                                            'doc': 'Return 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': {},
                                            'types': {}}],
                                'useNormal': [{'argInfo': {},
                                               'args': [],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': 'Determines 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': {},
                                               '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': 'Returns the name of this class.',
                                            'inArgs': [],
                                            'outArgs': [],
                                            'returnInfo': {'doc': 'Name of this class.',
                                                           'qualifiers': ['*'],
                                                           'type': 'char'},
                                            'returnType': 'char',
                                            'static': True,
                                            'typeQualifiers': {},
                                            'types': {}}],
                             'create': [{'argInfo': {},
                                         'args': [],
                                         'defaults': {},
                                         'deprecated': False,
                                         'doc': 'Creates an underlying Maya nId data object and return it as an MObject',
                                         'inArgs': [],
                                         'outArgs': [],
                                         'returnInfo': {'doc': 'The newly object.',
                                                        'qualifiers': [],
                                                        'type': 'MObject'},
                                         'returnType': 'MObject',
                                         'static': False,
                                         'typeQualifiers': {},
                                         'types': {}}],
                             'getObjectPtr': [{'argInfo': {},
                                               'args': [],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': 'Get the nObject pointer',
                                               'inArgs': [],
                                               'outArgs': [],
                                               'returnInfo': {'doc': 'the pointer to the N constraint',
                                                              'qualifiers': ['*'],
                                                              'type': 'MnObject'},
                                               'returnType': 'MnObject',
                                               'static': False,
                                               'typeQualifiers': {},
                                               'types': {}}],
                             'type': [{'argInfo': {},
                                       'args': [],
                                       'defaults': {},
                                       'deprecated': False,
                                       'doc': 'Function set type',
                                       'inArgs': [],
                                       'outArgs': [],
                                       'returnInfo': {'doc': 'the class type.',
                                                      'qualifiers': [],
                                                      'type': ('MFn', 'Type')},
                                       'returnType': ('MFn', 'Type'),
                                       'static': False,
                                       'typeQualifiers': {},
                                       'types': {}}]},
                 'pymelEnums': {}},
  'MFnNObjectData': {'enums': {},
                     'invertibles': [('setCached', 'isCached')],
                     'methods': {'className': [{'argInfo': {},
                                                'args': [],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': 'Returns the name of this class.',
                                                'inArgs': [],
                                                'outArgs': [],
                                                'returnInfo': {'doc': 'Name of this class.',
                                                               'qualifiers': ['*'],
                                                               'type': 'char'},
                                                'returnType': 'char',
                                                'static': True,
                                                'typeQualifiers': {},
                                                'types': {}}],
                                 'create': [{'argInfo': {},
                                             'args': [],
                                             'defaults': {},
                                             'deprecated': False,
                                             'doc': 'Creates 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': {}}],
                                 'getClothObjectPtr': [{'argInfo': {},
                                                        'args': [],
                                                        'defaults': {},
                                                        'deprecated': False,
                                                        'doc': 'Get the nObject pointer for an nCloth',
                                                        'inArgs': [],
                                                        'outArgs': [],
                                                        'returnInfo': {'doc': 'the pointer to the N cloth',
                                                                       'qualifiers': ['*'],
                                                                       'type': 'MnCloth'},
                                                        'returnType': 'MnCloth',
                                                        'static': False,
                                                        'typeQualifiers': {},
                                                        'types': {}}],
                                 'getCollide': [{'argInfo': {'collide': {'doc': 'the collision state',
                                                                         'type': 'bool'}},
                                                 'args': [('collide',
                                                           'bool',
                                                           'out')],
                                                 'defaults': {},
                                                 'deprecated': False,
                                                 'doc': 'Get 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'}}],
                                 'getParticleObjectPtr': [{'argInfo': {},
                                                           'args': [],
                                                           'defaults': {},
                                                           'deprecated': False,
                                                           'doc': 'Get the nObject pointer for an nParticle',
                                                           'inArgs': [],
                                                           'outArgs': [],
                                                           'returnInfo': {'doc': 'the pointer to the N particle',
                                                                          'qualifiers': ['*'],
                                                                          'type': 'MnParticle'},
                                                           'returnType': 'MnParticle',
                                                           'static': False,
                                                           'typeQualifiers': {},
                                                           'types': {}}],
                                 'getRigidObjectPtr': [{'argInfo': {},
                                                        'args': [],
                                                        'defaults': {},
                                                        'deprecated': False,
                                                        'doc': 'Get the nObject pointer for an nRigid',
                                                        'inArgs': [],
                                                        'outArgs': [],
                                                        'returnInfo': {'doc': 'the pointer to the N rigid',
                                                                       'qualifiers': ['*'],
                                                                       'type': 'MnRigid'},
                                                        'returnType': 'MnRigid',
                                                        'static': False,
                                                        'typeQualifiers': {},
                                                        'types': {}}],
                                 'isCached': [{'argInfo': {},
                                               'args': [],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': 'Get whether the nObject is cached.',
                                               'inArgs': [],
                                               'inverse': ('setCached', False),
                                               'outArgs': [],
                                               'returnInfo': {'doc': 'the cache state',
                                                              'qualifiers': [],
                                                              'type': 'bool'},
                                               'returnType': 'bool',
                                               'static': False,
                                               'typeQualifiers': {},
                                               'types': {}}],
                                 'setCached': [{'argInfo': {'cached': {'doc': 'the cache state',
                                                                       'type': 'bool'}},
                                                'args': [('cached',
                                                          'bool',
                                                          'in')],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': 'Set wether the nObject is cached.',
                                                'inArgs': ['cached'],
                                                'inverse': ('isCached', True),
                                                'outArgs': [],
                                                'returnInfo': {'doc': '',
                                                               'qualifiers': [],
                                                               'type': None},
                                                'returnType': None,
                                                'static': False,
                                                'typeQualifiers': {},
                                                'types': {'cached': 'bool'}}],
                                 'setObjectPtr': [{'argInfo': {'ptr': {'doc': 'pointer to the N cloth',
                                                                       'type': 'MnCloth'}},
                                                   'args': [('ptr',
                                                             'MnCloth',
                                                             'in')],
                                                   'defaults': {},
                                                   'deprecated': False,
                                                   'doc': 'Set the nCloth pointer',
                                                   'inArgs': ['ptr'],
                                                   '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': 'Set the nRigid pointer',
                                                   'inArgs': ['ptr'],
                                                   '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': 'Set the nParticle pointer',
                                                   'inArgs': ['ptr'],
                                                   'outArgs': [],
                                                   'returnInfo': {'doc': '',
                                                                  'qualifiers': [],
                                                                  'type': None},
                                                   'returnType': None,
                                                   'static': False,
                                                   'typeQualifiers': {'ptr': ['*']},
                                                   'types': {'ptr': 'MnParticle'}}],
                                 'type': [{'argInfo': {},
                                           'args': [],
                                           'defaults': {},
                                           'deprecated': False,
                                           'doc': 'Function set type',
                                           'inArgs': [],
                                           'outArgs': [],
                                           'returnInfo': {'doc': 'the class type.',
                                                          'qualifiers': [],
                                                          'type': ('MFn',
                                                                   'Type')},
                                           'returnType': ('MFn', 'Type'),
                                           'static': False,
                                           'typeQualifiers': {},
                                           'types': {}}]},
                     'pymelEnums': {}},
  'MFnNewtonField': {'enums': {},
                     'invertibles': [('setMinDistance', 'minDistance')],
                     'methods': {'className': [{'argInfo': {},
                                                'args': [],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': 'Returns the name of this class.',
                                                'inArgs': [],
                                                'outArgs': [],
                                                'returnInfo': {'doc': 'Name of this class.',
                                                               'qualifiers': ['*'],
                                                               'type': 'char'},
                                                'returnType': 'char',
                                                'static': True,
                                                'typeQualifiers': {},
                                                'types': {}}],
                                 'minDistance': [{'argInfo': {},
                                                  'args': [],
                                                  'defaults': {},
                                                  'deprecated': False,
                                                  'doc': 'Returns 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': {},
                                                  'types': {}}],
                                 'setMinDistance': [{'argInfo': {'distance': {'doc': 'A value representing distance in internal linear units.',
                                                                              'type': 'double'}},
                                                     'args': [('distance',
                                                               'double',
                                                               'in')],
                                                     'defaults': {},
                                                     'deprecated': False,
                                                     'doc': 'Sets 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': {},
                                                     'types': {'distance': 'double'}}],
                                 'type': [{'argInfo': {},
                                           'args': [],
                                           'defaults': {},
                                           'deprecated': False,
                                           'doc': 'Function set type',
                                           'inArgs': [],
                                           'outArgs': [],
                                           'returnInfo': {'doc': 'the class type.',
                                                          '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': 'Returns the name of this class.',
                                                    'inArgs': [],
                                                    'outArgs': [],
                                                    'returnInfo': {'doc': 'Name of this class.',
                                                                   'qualifiers': ['*'],
                                                                   'type': 'char'},
                                                    'returnType': 'char',
                                                    'static': True,
                                                    'typeQualifiers': {},
                                                    'types': {}}],
                                     'decayRate': [{'argInfo': {},
                                                    'args': [],
                                                    'defaults': {},
                                                    'deprecated': False,
                                                    'doc': 'Retrieves 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': {},
                                                    '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': 'Sets 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': 'Function set type',
                                               'inArgs': [],
                                               'outArgs': [],
                                               'returnInfo': {'doc': 'the class type.',
                                                              'qualifiers': [],
                                                              'type': ('MFn',
                                                                       'Type')},
                                               'returnType': ('MFn', 'Type'),
                                               'static': False,
                                               'typeQualifiers': {},
                                               'types': {}}]},
                         'pymelEnums': {},
                         'pymelMethods': {'decayRate': 'getDecayRate'}},
  'MFnNonExtendedLight': {'enums': {},
                          'invertibles': [('setCastSoftShadows',
                                           'castSoftShadows'),
                                          ('setDepthMapBias', 'depthMapBias'),
                                          ('setDepthMapFilterSize',
                                           'depthMapFilterSize'),
                                          ('setDepthMapFocus', 'depthMapFocus'),
                                          ('setDepthMapResolution',
                                           'depthMapResolution'),
                                          ('setDepthMapWidthFocus',
                                           'depthMapWidthFocus'),
                                          ('setShadowRadius', 'shadowRadius'),
                                          ('setUseDepthMapAutoFocus',
                                           'useDepthMapAutoFocus'),
                                          ('setUseDepthMapShadows',
                                           'useDepthMapShadows')],
                          'methods': {'castSoftShadows': [{'argInfo': {},
                                                           'args': [],
                                                           'defaults': {},
                                                           'deprecated': False,
                                                           'doc': 'Retrieves 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': {},
                                                           'types': {}}],
                                      'className': [{'argInfo': {},
                                                     'args': [],
                                                     'defaults': {},
                                                     'deprecated': False,
                                                     'doc': 'Returns the name of this class.',
                                                     'inArgs': [],
                                                     'outArgs': [],
                                                     'returnInfo': {'doc': 'Name of this class.',
                                                                    'qualifiers': ['*'],
                                                                    'type': 'char'},
                                                     'returnType': 'char',
                                                     'static': True,
                                                     'typeQualifiers': {},
                                                     'types': {}}],
                                      'depthMapBias': [{'argInfo': {},
                                                        'args': [],
                                                        'defaults': {},
                                                        'deprecated': False,
                                                        'doc': 'Retrieves 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': {},
                                                        'types': {}}],
                                      'depthMapFilterSize': [{'argInfo': {},
                                                              'args': [],
                                                              'defaults': {},
                                                              'deprecated': False,
                                                              'doc': 'Retrieves 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': {},
                                                              'types': {}}],
                                      'depthMapFocus': [{'argInfo': {},
                                                         'args': [],
                                                         'defaults': {},
                                                         'deprecated': False,
                                                         'doc': 'Retrieves 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': {},
                                                         'types': {}}],
                                      'depthMapResolution': [{'argInfo': {},
                                                              'args': [],
                                                              'defaults': {},
                                                              'deprecated': False,
                                                              'doc': 'Retrieves 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': {},
                                                              'types': {}}],
                                      'depthMapWidthFocus': [{'argInfo': {},
                                                              'args': [],
                                                              'defaults': {},
                                                              'deprecated': False,
                                                              'doc': 'Retrieves 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': {},
                                                              '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': 'Sets 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': 'Sets 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': 'Sets 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': 'Sets 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': 'Sets 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': 'Sets 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': 'Sets 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': 'Sets 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': 'Sets 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': 'Retrieves 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': {},
                                                        'types': {}}],
                                      'type': [{'argInfo': {},
                                                'args': [],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': 'Function set type',
                                                'inArgs': [],
                                                'outArgs': [],
                                                'returnInfo': {'doc': 'the class type.',
                                                               'qualifiers': [],
                                                               'type': ('MFn',
                                                                        'Type')},
                                                'returnType': ('MFn', 'Type'),
                                                'static': False,
                                                'typeQualifiers': {},
                                                'types': {}}],
                                      'useDepthMapAutoFocus': [{'argInfo': {},
                                                                'args': [],
                                                                'defaults': {},
                                                                'deprecated': False,
                                                                'doc': 'Retrieves 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': {},
                                                                'types': {}}],
                                      'useDepthMapShadows': [{'argInfo': {},
                                                              'args': [],
                                                              'defaults': {},
                                                              'deprecated': False,
                                                              'doc': 'Retrieves 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': {},
                                                              'types': {}}]},
                          'pymelEnums': {},
                          'pymelMethods': {'castSoftShadows': 'getCastSoftShadows',
                                           'depthMapBias': 'getDepthMapBias',
                                           'depthMapFilterSize': 'getDepthMapFilterSize',
                                           'depthMapFocus': 'getDepthMapFocus',
                                           'depthMapResolution': 'getDepthMapResolution',
                                           'depthMapWidthFocus': 'getDepthMapWidthFocus',
                                           'shadowRadius': 'getShadowRadius',
                                           'useDepthMapAutoFocus': 'getUseDepthMapAutoFocus',
                                           'useDepthMapShadows': 'getUseDepthMapShadows'}},
  'MFnNumericAttribute': {'enums': {},
                          'invertibles': [('setDefault', 'getDefault'),
                                          ('setMax', 'getMax'),
                                          ('setMin', 'getMin'),
                                          ('setSoftMax', 'getSoftMax'),
                                          ('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': 'Return 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': {'index': ['unsigned']},
                                                 'types': {'index': 'uint'}}],
                                      'className': [{'argInfo': {},
                                                     'args': [],
                                                     'defaults': {},
                                                     'deprecated': False,
                                                     'doc': 'Returns the name of this class.',
                                                     'inArgs': [],
                                                     'outArgs': [],
                                                     'returnInfo': {'doc': 'Name of this class.',
                                                                    'qualifiers': ['*'],
                                                                    'type': 'char'},
                                                     'returnType': 'char',
                                                     'static': True,
                                                     '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': 'Create 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': {'brief': ['const',
                                                                               '&'],
                                                                     'full': ['const',
                                                                              '&']},
                                                  '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': 'Create 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': {'brief': ['const',
                                                                               '&'],
                                                                     'child1': ['const',
                                                                                '&'],
                                                                     'child2': ['const',
                                                                                '&'],
                                                                     'child3': ['const',
                                                                                '&'],
                                                                     'full': ['const',
                                                                              '&']},
                                                  'types': {'brief': 'MString',
                                                            'child1': 'MObject',
                                                            'child2': 'MObject',
                                                            'child3': 'MObject',
                                                            'full': 'MString'}},
                                                 {'argInfo': {'brief': {'doc': 'the brief (or short) name of the attribute',
                                                                        'type': 'MString'},
                                                              'child1': {'doc': 'the first of the four numeric attributes',
                                                                         'type': 'MObject'},
                                                              'child2': {'doc': 'the second of the four numeric attributes',
                                                                         'type': 'MObject'},
                                                              'child3': {'doc': 'the third of the four numeric attributes',
                                                                         'type': 'MObject'},
                                                              'child4': {'doc': 'the fourth of the four numeric attributes',
                                                                         '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'),
                                                           ('child4',
                                                            'MObject',
                                                            'in')],
                                                  'defaults': {},
                                                  'deprecated': False,
                                                  'doc': 'Create a new numeric attribute and return it as an MObject. This form of the create method allows the creation of a compound attribute having four 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',
                                                             'child4'],
                                                  'outArgs': [],
                                                  'returnInfo': {'doc': 'An MObject representing the new attribute',
                                                                 'qualifiers': [],
                                                                 'type': 'MObject'},
                                                  'returnType': 'MObject',
                                                  'static': False,
                                                  'typeQualifiers': {'brief': ['const',
                                                                               '&'],
                                                                     'child1': ['const',
                                                                                '&'],
                                                                     'child2': ['const',
                                                                                '&'],
                                                                     'child3': ['const',
                                                                                '&'],
                                                                     'child4': ['const',
                                                                                '&'],
                                                                     'full': ['const',
                                                                              '&']},
                                                  'types': {'brief': 'MString',
                                                            'child1': 'MObject',
                                                            'child2': 'MObject',
                                                            'child3': 'MObject',
                                                            'child4': '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': 'Create 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': {'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': 'Create 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': {'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': 'Create 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': {'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': 'Get 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': 'Get 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': 'Gets 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': 'Gets 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': 'Gets 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': 'Gets 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': 'Gets 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': 'Gets 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': 'Gets 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': 'Get 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': 'Gets 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': 'Gets 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': 'Gets 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': 'Get 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': 'Return 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': 'Return 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': 'Return 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'}},
                                                 {'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'},
                                                              'max4': {'doc': 'the maximum value for the fourth child attribute',
                                                                       'type': 'double'}},
                                                  'args': [('max1',
                                                            'double',
                                                            'out'),
                                                           ('max2',
                                                            'double',
                                                            'out'),
                                                           ('max3',
                                                            'double',
                                                            'out'),
                                                           ('max4',
                                                            'double',
                                                            'out')],
                                                  'defaults': {},
                                                  'deprecated': False,
                                                  'doc': 'Return the maximum values for the four children (all double attributes) of this compound attribute.',
                                                  'inArgs': [],
                                                  'inverse': ('setMax', False),
                                                  'outArgs': ['max1',
                                                              'max2',
                                                              'max3',
                                                              'max4'],
                                                  'returnInfo': {'doc': '',
                                                                 'qualifiers': [],
                                                                 'type': None},
                                                  'returnType': None,
                                                  'static': False,
                                                  'typeQualifiers': {'max1': ['&'],
                                                                     'max2': ['&'],
                                                                     'max3': ['&'],
                                                                     'max4': ['&']},
                                                  'types': {'max1': 'double',
                                                            'max2': 'double',
                                                            'max3': 'double',
                                                            'max4': 'double'}}],
                                      'getMin': [{'argInfo': {'min': {'doc': 'the minimum value for this attribute',
                                                                      'type': 'double'}},
                                                  'args': [('min',
                                                            'double',
                                                            'out')],
                                                  'defaults': {},
                                                  'deprecated': False,
                                                  'doc': 'Return 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': 'Return 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': 'Return 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'}},
                                                 {'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'},
                                                              'min4': {'doc': 'the minimum value for the fourth child attribute',
                                                                       'type': 'double'}},
                                                  'args': [('min1',
                                                            'double',
                                                            'out'),
                                                           ('min2',
                                                            'double',
                                                            'out'),
                                                           ('min3',
                                                            'double',
                                                            'out'),
                                                           ('min4',
                                                            'double',
                                                            'out')],
                                                  'defaults': {},
                                                  'deprecated': False,
                                                  'doc': 'Return the minimum values for the four children (all double attributes) of this compound attribute.',
                                                  'inArgs': [],
                                                  'inverse': ('setMin', False),
                                                  'outArgs': ['min1',
                                                              'min2',
                                                              'min3',
                                                              'min4'],
                                                  'returnInfo': {'doc': '',
                                                                 'qualifiers': [],
                                                                 'type': None},
                                                  'returnType': None,
                                                  'static': False,
                                                  'typeQualifiers': {'min1': ['&'],
                                                                     'min2': ['&'],
                                                                     'min3': ['&'],
                                                                     'min4': ['&']},
                                                  'types': {'min1': 'double',
                                                            'min2': 'double',
                                                            'min3': 'double',
                                                            'min4': 'double'}}],
                                      'getSoftMax': [{'argInfo': {'max': {'doc': 'the soft maximum value for this attribute',
                                                                          'type': 'double'}},
                                                      'args': [('max',
                                                                'double',
                                                                'out')],
                                                      'defaults': {},
                                                      'deprecated': False,
                                                      'doc': 'Return 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': 'Return 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': 'Determine 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': {},
                                                  'types': {}}],
                                      'hasMin': [{'argInfo': {},
                                                  'args': [],
                                                  'defaults': {},
                                                  'deprecated': False,
                                                  'doc': 'Determine 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': {},
                                                  'types': {}}],
                                      'hasSoftMax': [{'argInfo': {},
                                                      'args': [],
                                                      'defaults': {},
                                                      'deprecated': False,
                                                      'doc': 'Determine 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': {},
                                                      'types': {}}],
                                      'hasSoftMin': [{'argInfo': {},
                                                      'args': [],
                                                      'defaults': {},
                                                      'deprecated': False,
                                                      'doc': 'Determine 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': {},
                                                      'types': {}}],
                                      'setDefault': [{'argInfo': {'def1': {'doc': 'new the default value for this attribute',
                                                                           'type': 'bool'}},
                                                      'args': [('def1',
                                                                'bool',
                                                                'in')],
                                                      'defaults': {},
                                                      'deprecated': False,
                                                      'doc': 'Set a new default value for this boolean attribute.',
                                                      'inArgs': ['def1'],
                                                      'inverse': ('getDefault',
                                                                  True),
                                                      'outArgs': [],
                                                      'returnInfo': {'doc': '',
                                                                     'qualifiers': [],
                                                                     'type': None},
                                                      'returnType': None,
                                                      'static': False,
                                                      'typeQualifiers': {},
                                                      'types': {'def1': 'bool'}},
                                                     {'argInfo': {'def1': {'doc': 'new the default value for this attribute',
                                                                           'type': 'char'}},
                                                      'args': [('def1',
                                                                'char',
                                                                'in')],
                                                      'defaults': {},
                                                      'deprecated': False,
                                                      'doc': 'Set a new default value for this character attribute.',
                                                      'inArgs': ['def1'],
                                                      'inverse': ('getDefault',
                                                                  True),
                                                      'outArgs': [],
                                                      'returnInfo': {'doc': '',
                                                                     'qualifiers': [],
                                                                     'type': None},
                                                      'returnType': None,
                                                      'static': False,
                                                      'typeQualifiers': {},
                                                      'types': {'def1': 'char'}},
                                                     {'argInfo': {'def1': {'doc': 'new the default value for this attribute',
                                                                           'type': 'int'}},
                                                      'args': [('def1',
                                                                'int',
                                                                'in')],
                                                      'defaults': {},
                                                      'deprecated': False,
                                                      'doc': 'Set 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': {},
                                                      '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': 'Set 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': {},
                                                      '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': 'Set 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': {},
                                                      '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': 'Set 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': {},
                                                      'types': {'def1': 'MInt64'}},
                                                     {'argInfo': {'def1': {'doc': 'new the default value for this attribute',
                                                                           'type': 'float'}},
                                                      'args': [('def1',
                                                                'float',
                                                                'in')],
                                                      'defaults': {},
                                                      'deprecated': False,
                                                      'doc': 'Set a new default value for this float attribute.',
                                                      'inArgs': ['def1'],
                                                      'inverse': ('getDefault',
                                                                  True),
                                                      'outArgs': [],
                                                      'returnInfo': {'doc': '',
                                                                     'qualifiers': [],
                                                                     'type': None},
                                                      'returnType': None,
                                                      'static': False,
                                                      'typeQualifiers': {},
                                                      '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': 'Set 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': {},
                                                      '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': 'Set 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': {},
                                                      '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': 'Set a new default value for this double attribute.',
                                                      'inArgs': ['def1'],
                                                      'inverse': ('getDefault',
                                                                  True),
                                                      'outArgs': [],
                                                      'returnInfo': {'doc': '',
                                                                     'qualifiers': [],
                                                                     'type': None},
                                                      'returnType': None,
                                                      'static': False,
                                                      'typeQualifiers': {},
                                                      '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': 'Set 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': {},
                                                      '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': 'Set 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': {},
                                                      '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': 'Set 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': {},
                                                      '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': 'Set 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': 'Set the maximum value for this double attribute.',
                                                  'inArgs': ['max'],
                                                  'inverse': ('getMax', True),
                                                  'outArgs': [],
                                                  'returnInfo': {'doc': '',
                                                                 'qualifiers': [],
                                                                 'type': None},
                                                  'returnType': None,
                                                  'static': False,
                                                  'typeQualifiers': {},
                                                  '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': 'Set 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': {},
                                                  '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': 'Set 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': {},
                                                  'types': {'max1': 'double',
                                                            'max2': 'double',
                                                            'max3': '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'},
                                                              'max4': {'doc': 'the maximum value for the fourth child attribute',
                                                                       'type': 'double'}},
                                                  'args': [('max1',
                                                            'double',
                                                            'in'),
                                                           ('max2',
                                                            'double',
                                                            'in'),
                                                           ('max3',
                                                            'double',
                                                            'in'),
                                                           ('max4',
                                                            'double',
                                                            'in')],
                                                  'defaults': {},
                                                  'deprecated': False,
                                                  'doc': 'Set the maximum values for the four children (all double attributes) of this compound attribute.',
                                                  'inArgs': ['max1',
                                                             'max2',
                                                             'max3',
                                                             'max4'],
                                                  'inverse': ('getMax', True),
                                                  'outArgs': [],
                                                  'returnInfo': {'doc': '',
                                                                 'qualifiers': [],
                                                                 'type': None},
                                                  'returnType': None,
                                                  'static': False,
                                                  'typeQualifiers': {},
                                                  'types': {'max1': 'double',
                                                            'max2': 'double',
                                                            'max3': 'double',
                                                            'max4': 'double'}}],
                                      'setMin': [{'argInfo': {'min': {'doc': 'the minimum value for this attribute',
                                                                      'type': 'double'}},
                                                  'args': [('min',
                                                            'double',
                                                            'in')],
                                                  'defaults': {},
                                                  'deprecated': False,
                                                  'doc': 'Set the minimum value for this double attribute.',
                                                  'inArgs': ['min'],
                                                  'inverse': ('getMin', True),
                                                  'outArgs': [],
                                                  'returnInfo': {'doc': '',
                                                                 'qualifiers': [],
                                                                 'type': None},
                                                  'returnType': None,
                                                  'static': False,
                                                  'typeQualifiers': {},
                                                  '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': 'Set 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': {},
                                                  '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': 'Set 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': {},
                                                  'types': {'min1': 'double',
                                                            'min2': 'double',
                                                            'min3': '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'},
                                                              'min4': {'doc': 'the minimum value for the fourth child attribute',
                                                                       'type': 'double'}},
                                                  'args': [('min1',
                                                            'double',
                                                            'in'),
                                                           ('min2',
                                                            'double',
                                                            'in'),
                                                           ('min3',
                                                            'double',
                                                            'in'),
                                                           ('min4',
                                                            'double',
                                                            'in')],
                                                  'defaults': {},
                                                  'deprecated': False,
                                                  'doc': 'Set the minimum values for the four children (all double attributes) of this compound attribute.',
                                                  'inArgs': ['min1',
                                                             'min2',
                                                             'min3',
                                                             'min4'],
                                                  'inverse': ('getMin', True),
                                                  'outArgs': [],
                                                  'returnInfo': {'doc': '',
                                                                 'qualifiers': [],
                                                                 'type': None},
                                                  'returnType': None,
                                                  'static': False,
                                                  'typeQualifiers': {},
                                                  'types': {'min1': 'double',
                                                            'min2': 'double',
                                                            'min3': 'double',
                                                            'min4': 'double'}}],
                                      'setSoftMax': [{'argInfo': {'max': {'doc': 'the soft maximum value for this attribute',
                                                                          'type': 'double'}},
                                                      'args': [('max',
                                                                'double',
                                                                'in')],
                                                      'defaults': {},
                                                      'deprecated': False,
                                                      'doc': 'Set the soft maximum value for this double attribute.',
                                                      'inArgs': ['max'],
                                                      'inverse': ('getSoftMax',
                                                                  True),
                                                      'outArgs': [],
                                                      'returnInfo': {'doc': '',
                                                                     'qualifiers': [],
                                                                     'type': None},
                                                      'returnType': None,
                                                      'static': False,
                                                      'typeQualifiers': {},
                                                      'types': {'max': 'double'}}],
                                      'setSoftMin': [{'argInfo': {'min': {'doc': 'the minimum value for this attribute',
                                                                          'type': 'double'}},
                                                      'args': [('min',
                                                                'double',
                                                                'in')],
                                                      'defaults': {},
                                                      'deprecated': False,
                                                      'doc': 'Set the soft minimum value for this double attribute.',
                                                      'inArgs': ['min'],
                                                      'inverse': ('getSoftMin',
                                                                  True),
                                                      'outArgs': [],
                                                      'returnInfo': {'doc': '',
                                                                     'qualifiers': [],
                                                                     'type': None},
                                                      'returnType': None,
                                                      'static': False,
                                                      'typeQualifiers': {},
                                                      'types': {'min': 'double'}}],
                                      'type': [{'argInfo': {},
                                                'args': [],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': 'Function set type',
                                                'inArgs': [],
                                                'outArgs': [],
                                                'returnInfo': {'doc': 'the class type.',
                                                               'qualifiers': [],
                                                               'type': ('MFn',
                                                                        'Type')},
                                                'returnType': ('MFn', 'Type'),
                                                'static': False,
                                                'typeQualifiers': {},
                                                'types': {}}],
                                      'unitType': [{'argInfo': {},
                                                    'args': [],
                                                    'defaults': {},
                                                    'deprecated': False,
                                                    'doc': 'Return 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': {},
                                                    '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), ('k2Long', 8), ('k2Int', 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': [('setData2Double', 'getData2Double'),
                                     ('setData2Float', 'getData2Float'),
                                     ('setData2Int', 'getData2Int'),
                                     ('setData2Short', 'getData2Short'),
                                     ('setData3Double', 'getData3Double'),
                                     ('setData3Float', 'getData3Float'),
                                     ('setData3Int', 'getData3Int'),
                                     ('setData3Short', 'getData3Short'),
                                     ('setData4Double', 'getData4Double')],
                     'methods': {'className': [{'argInfo': {},
                                                'args': [],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': 'Returns the name of this class.',
                                                'inArgs': [],
                                                'outArgs': [],
                                                'returnInfo': {'doc': 'Name of this class.',
                                                               'qualifiers': ['*'],
                                                               'type': 'char'},
                                                'returnType': 'char',
                                                'static': True,
                                                'typeQualifiers': {},
                                                'types': {}}],
                                 'create': [{'argInfo': {'dataType': {'doc': 'data type of object to create',
                                                                      'type': ('MFnNumericData',
                                                                               'Type')}},
                                             'args': [('dataType',
                                                       ('MFnNumericData',
                                                        'Type'),
                                                       'in')],
                                             'defaults': {},
                                             'deprecated': False,
                                             'doc': 'Creates 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': {},
                                             'types': {'dataType': ('MFnNumericData',
                                                                    'Type')}}],
                                 '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': 'Gets 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': 'Gets 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': 'Gets 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': 'Gets 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': 'Gets 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': 'Gets 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': 'Gets 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': 'Gets 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': 'Gets 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': 'Returns the type of the numeric data object.',
                                                  'inArgs': [],
                                                  'outArgs': [],
                                                  'returnInfo': {'doc': 'Type of data',
                                                                 'qualifiers': [],
                                                                 'type': ('MFnNumericData',
                                                                          'Type')},
                                                  'returnType': ('MFnNumericData',
                                                                 'Type'),
                                                  'static': False,
                                                  'typeQualifiers': {},
                                                  'types': {}}],
                                 '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': 'Sets 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': {},
                                                     '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': 'Sets 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': {},
                                                    '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': 'Sets 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': {},
                                                  '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': 'Sets 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': {},
                                                    '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': 'Sets 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': {},
                                                     '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': 'Sets 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': {},
                                                    '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': 'Sets 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': {},
                                                  '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': 'Sets 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': {},
                                                    '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': 'Sets 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': {},
                                                     'types': {'val1': 'double',
                                                               'val2': 'double',
                                                               'val3': 'double',
                                                               'val4': 'double'}}],
                                 'type': [{'argInfo': {},
                                           'args': [],
                                           'defaults': {},
                                           'deprecated': False,
                                           'doc': 'Function set type',
                                           'inArgs': [],
                                           'outArgs': [],
                                           'returnInfo': {'doc': 'the class type.',
                                                          '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), ('k2Long', 8), ('k2Int', 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.',
                                                     'kClosed': 'Endpoints are coincident.',
                                                     'kOpen': 'Ends are independent.',
                                                     'kPeriodic': 'Ends overlap such that there is no break in tangency.',
                                                     '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': [('setCV', 'getCV'),
                                    ('setCVs', 'getCVs'),
                                    ('setKnot', 'knot'),
                                    ('setKnots', 'getKnots')],
                    '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': 'This 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': {},
                                          'types': {'tolerance': 'double'}}],
                                'className': [{'argInfo': {},
                                               'args': [],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': 'Returns the name of this class.',
                                               'inArgs': [],
                                               'outArgs': [],
                                               'returnInfo': {'doc': 'Name of this class.',
                                                              'qualifiers': ['*'],
                                                              'type': 'char'},
                                               'returnType': 'char',
                                               'static': True,
                                               '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': 'This 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': {'param': ['*'],
                                                                     'toThisPoint': ['const',
                                                                                     '&']},
                                                  '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': 'This 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': {'param': ['*'],
                                                                     'toThisPoint': ['const',
                                                                                     '&']},
                                                  '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': 'This 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': {'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': 'This 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': {'controlVertices': ['const',
                                                                                   '&'],
                                                               'degree': ['unsigned'],
                                                               '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': 'This 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:',
                                            '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': {'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': 'This 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': {'degree': ['unsigned'],
                                                                             'editPoints': ['const',
                                                                                            '&'],
                                                                             'parentOrOwner': ['&']},
                                                          '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': 'Returns 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': {'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': 'Returns 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': {'endIndex': ['unsigned'],
                                                            'startIndex': ['unsigned']},
                                         'types': {'endIndex': 'uint',
                                                   'startIndex': 'uint'}}],
                                'degree': [{'argInfo': {},
                                            'args': [],
                                            'defaults': {},
                                            'deprecated': False,
                                            'doc': 'Return 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': {},
                                            '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': 'Returns 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': {'pt': ['const',
                                                                               '&']},
                                                     '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': 'Returns 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': {},
                                                         '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': 'Returns 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': {},
                                                         'types': {'partLength': 'double'}},
                                                        {'argInfo': {'partLength': {'doc': 'Length along the curve to find parameter value at',
                                                                                    'type': 'double'},
                                                                     'tolerance': {'doc': 'The search tolerance',
                                                                                   'type': 'double'}},
                                                         'args': [('partLength',
                                                                   'double',
                                                                   'in'),
                                                                  ('tolerance',
                                                                   'double',
                                                                   'in')],
                                                         'defaults': {},
                                                         'deprecated': False,
                                                         'doc': 'Returns the parameter value corresponding to a given length along the curve with the given tolerance. 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',
                                                                    'tolerance'],
                                                         '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': {},
                                                         'types': {'partLength': 'double',
                                                                   'tolerance': 'double'}}],
                                'form': [{'argInfo': {},
                                          'args': [],
                                          'defaults': {},
                                          'deprecated': False,
                                          'doc': 'This 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': {},
                                          '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': 'Get 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': ['&']},
                                           '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': 'Get 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': ['&']},
                                            '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': 'Evaluate 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': ['*'],
                                                                             'pos': ['&']},
                                                          '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': 'Return 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': 'This 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': 'This 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': ['&']},
                                                     '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': 'This 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': ['&']},
                                                     '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': 'Returns 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': {'point': ['&']},
                                                     'types': {'param': 'double',
                                                               'point': 'MPoint',
                                                               'space': ('MSpace',
                                                                         'Space')}}],
                                'hasHistoryOnCreate': [{'argInfo': {},
                                                        'args': [],
                                                        'defaults': {},
                                                        'deprecated': False,
                                                        'doc': 'This 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': {},
                                                        'types': {}}],
                                'isParamOnCurve': [{'argInfo': {'param': {'doc': 'The parameter value to check',
                                                                          'type': 'double'}},
                                                    'args': [('param',
                                                              'double',
                                                              'in')],
                                                    'defaults': {},
                                                    'deprecated': False,
                                                    'doc': 'Determines 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': {},
                                                    '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': 'This 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': {'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': 'Determines 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': {'point': ['const',
                                                                                 '&']},
                                                    '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': 'Get 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': {'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': 'Return 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': {},
                                            'types': {'tolerance': 'double'}}],
                                'makeMultipleEndKnots': [{'argInfo': {},
                                                          'args': [],
                                                          'defaults': {},
                                                          'deprecated': False,
                                                          'doc': 'This 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': 'This 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': {},
                                            'types': {'param': 'double',
                                                      'space': ('MSpace',
                                                                'Space')}}],
                                'numCVs': [{'argInfo': {},
                                            'args': [],
                                            'defaults': {},
                                            'deprecated': False,
                                            'doc': 'Return 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': {},
                                            'types': {}}],
                                'numKnots': [{'argInfo': {},
                                              'args': [],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': 'Return 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': {},
                                              'types': {}}],
                                'numSpans': [{'argInfo': {},
                                              'args': [],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': 'Return 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': {},
                                              '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.01},
                                             'deprecated': False,
                                             'doc': 'This 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': {'degree': ['unsigned'],
                                                                'endKnots': ['unsigned'],
                                                                'keepRange': ['unsigned'],
                                                                'spans': ['unsigned']},
                                             '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': 'Remove one or more knots at the given parameter.',
                                                'inArgs': ['atThisParam',
                                                           'removeAll'],
                                                'outArgs': [],
                                                'returnInfo': {'doc': '',
                                                               'qualifiers': [],
                                                               'type': None},
                                                'returnType': None,
                                                'static': False,
                                                'typeQualifiers': {},
                                                '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': 'This method reverse the curve direction.',
                                             'inArgs': ['constructionHistory'],
                                             'outArgs': [],
                                             'returnInfo': {'doc': '',
                                                            'qualifiers': [],
                                                            'type': None},
                                             'returnType': None,
                                             'static': False,
                                             'typeQualifiers': {},
                                             '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': 'Set 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',
                                                                     '&']},
                                           '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': 'Set 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',
                                                                         '&']},
                                            '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': "Set 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']},
                                             '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': 'This 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': 'This 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': {},
                                             'types': {'param': 'double',
                                                       'space': ('MSpace',
                                                                 'Space')}}],
                                'type': [{'argInfo': {},
                                          'args': [],
                                          'defaults': {},
                                          'deprecated': False,
                                          'doc': 'Function set type',
                                          'inArgs': [],
                                          'outArgs': [],
                                          'returnInfo': {'doc': 'the class type.',
                                                         'qualifiers': [],
                                                         'type': ('MFn',
                                                                  'Type')},
                                          'returnType': ('MFn', 'Type'),
                                          'static': False,
                                          'typeQualifiers': {},
                                          'types': {}}],
                                'updateCurve': [{'argInfo': {},
                                                 'args': [],
                                                 'defaults': {},
                                                 'deprecated': False,
                                                 'doc': 'This 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': 'Returns the name of this class.',
                                                   'inArgs': [],
                                                   'outArgs': [],
                                                   'returnInfo': {'doc': 'Name of this class.',
                                                                  'qualifiers': ['*'],
                                                                  'type': 'char'},
                                                   'returnType': 'char',
                                                   'static': True,
                                                   'typeQualifiers': {},
                                                   'types': {}}],
                                    'create': [{'argInfo': {},
                                                'args': [],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': 'Create 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': {},
                                                'types': {}}],
                                    'type': [{'argInfo': {},
                                              'args': [],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': 'Function set type',
                                              'inArgs': [],
                                              'outArgs': [],
                                              'returnInfo': {'doc': 'the class type.',
                                                             '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.',
                                                               'kClosedSegment': 'Closed curve on a face.',
                                                               'kInner': 'Inner boundary, clockwise.',
                                                               '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.',
                                                       'kClosed': 'Edges are coincident.',
                                                       'kOpen': 'Edges are independent.',
                                                       'kPeriodic': 'Edges overlap such that there is no break in tangency.',
                                                       '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': [('setCV', 'getCV'),
                                      ('setCVs', 'getCVs'),
                                      ('setKnotInU', 'knotInU'),
                                      ('setKnotInV', 'knotInV'),
                                      ('setKnotsInU', 'getKnotsInU'),
                                      ('setKnotsInV', 'getKnotsInV'),
                                      ('setUV', 'getUV'),
                                      ('setUVs', 'getUVs')],
                      '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': 'Calculates 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': {},
                                            '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': 'Calculates 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': {},
                                            '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': 'Maps 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': {},
                                                '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': 'This 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': 'Returns 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': {'boundary': ['unsigned'],
                                                                       'region': ['unsigned']},
                                                    'types': {'boundary': 'uint',
                                                              'region': 'uint'}}],
                                  'className': [{'argInfo': {},
                                                 'args': [],
                                                 'defaults': {},
                                                 'deprecated': False,
                                                 'doc': 'Returns the name of this class.',
                                                 'inArgs': [],
                                                 'outArgs': [],
                                                 'returnInfo': {'doc': 'Name of this class.',
                                                                'qualifiers': ['*'],
                                                                'type': 'char'},
                                                 'returnType': 'char',
                                                 'static': True,
                                                 'typeQualifiers': {},
                                                 'types': {}}],
                                  'clearUVs': [{'argInfo': {},
                                                'args': [],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': 'This 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': 'Return 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': {'paramU': ['*'],
                                                                       'paramV': ['*'],
                                                                       'toThisPoint': ['const',
                                                                                       '&']},
                                                    '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': 'Return 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': {'paramU': ['*'],
                                                                       'paramV': ['*'],
                                                                       'toThisPoint': ['const',
                                                                                       '&']},
                                                    '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': 'This 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': {'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': 'Creates 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': {'controlVertices': ['const',
                                                                                     '&'],
                                                                 'degreeInU': ['unsigned'],
                                                                 'degreeInV': ['unsigned'],
                                                                 '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': 'Returns a component for the specified CV.',
                                          'inArgs': ['indexU', 'indexV'],
                                          'outArgs': [],
                                          'returnInfo': {'doc': 'The cv component',
                                                         'qualifiers': [],
                                                         'type': 'MObject'},
                                          'returnType': 'MObject',
                                          'static': False,
                                          'typeQualifiers': {'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': 'Returns 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': {'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': 'Returns 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': {'endIndex': ['unsigned'],
                                                                 'rowIndex': ['unsigned'],
                                                                 'startIndex': ['unsigned']},
                                              'types': {'endIndex': 'uint',
                                                        'rowIndex': 'uint',
                                                        'startIndex': 'uint'}}],
                                  'degreeU': [{'argInfo': {},
                                               'args': [],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': 'Returns 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': {},
                                               'types': {}}],
                                  'degreeV': [{'argInfo': {},
                                               'args': [],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': 'Returns 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': {},
                                               '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': 'Returns 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': {'pt': ['const',
                                                                                 '&']},
                                                       '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': 'Return 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': {'boundary': ['unsigned'],
                                                               'edge': ['unsigned'],
                                                               'region': ['unsigned']},
                                            'types': {'boundary': 'uint',
                                                      'edge': 'uint',
                                                      'paramEdge': 'bool',
                                                      'region': 'uint'}}],
                                  'formInU': [{'argInfo': {},
                                               'args': [],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': 'Return 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': {},
                                               'types': {}}],
                                  'formInV': [{'argInfo': {},
                                               'args': [],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': 'Return 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': {},
                                               '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': 'Get 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': 'Get 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': ['&']},
                                             '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': 'Get 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': ['&']},
                                              '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': 'Returns 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': 'Returns an MObject if the class has been constructed with an MFn::kNurbsSurfaceData entity, otherwise MObject::kNullObj is returned.',
                                                     'inArgs': [],
                                                     'outArgs': [],
                                                     'returnInfo': {'doc': 'An MObject',
                                                                    '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': 'Evaluate 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': ['*'],
                                                                               'pos': ['&']},
                                                            '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': 'Returns 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': 'Get 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': 'Get 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': 'Get 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',
                                                                                          '&'],
                                                                          'paramU': ['&'],
                                                                          'paramV': ['&']},
                                                       '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': 'This method is obsolete. [as of Maya 2019]',
                                                       'inArgs': ['atThisPoint',
                                                                  'space'],
                                                       'outArgs': ['paramU',
                                                                   'paramV'],
                                                       'returnInfo': {'doc': '',
                                                                      'qualifiers': [],
                                                                      'type': None},
                                                       'returnType': None,
                                                       'static': False,
                                                       'typeQualifiers': {'atThisPoint': ['const',
                                                                                          '&'],
                                                                          'paramU': ['&'],
                                                                          'paramV': ['&']},
                                                       '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': "Get 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': {'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': 'Get 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': {'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': 'Get 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': {'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': 'Finds 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': {'point': ['&']},
                                                       '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': 'Retrieve 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': {'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': 'Returns all trim boundaries of a region on this surface.',
                                                         'inArgs': ['region',
                                                                    'paramEdge'],
                                                         'outArgs': ['result'],
                                                         'returnInfo': {'doc': '',
                                                                        'qualifiers': [],
                                                                        'type': None},
                                                         'returnType': None,
                                                         'static': False,
                                                         'typeQualifiers': {'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': "Get 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': ['&'],
                                                                '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': 'This 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': 'This 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': {},
                                                          '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': 'This 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': {'alongThisDirection': ['const',
                                                                                           '&'],
                                                                    'distance': ['*'],
                                                                    'pntOfIntersection': ['&'],
                                                                    'rayStartingPoint': ['const',
                                                                                         '&'],
                                                                    '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': 'This 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': {'alongThisDirection': ['const',
                                                                                           '&'],
                                                                    'distances': ['*'],
                                                                    'points': ['&'],
                                                                    'rayStartingPoint': ['const',
                                                                                         '&'],
                                                                    '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': 'Determine 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': {},
                                                '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': 'Determines 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': {'region': ['unsigned']},
                                                  'types': {'region': 'uint'}}],
                                  'isFoldedOnBispan': [{'argInfo': {},
                                                        'args': [],
                                                        'defaults': {},
                                                        'deprecated': False,
                                                        'doc': 'Evaluate 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': 'true There are folds or creases detected false The surface is believed to have continuous curvature',
                                                                       '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': 'Check 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': {},
                                               'types': {'param': 'double'}}],
                                  'isKnotV': [{'argInfo': {'param': {'doc': 'parameter value to test',
                                                                     'type': 'double'}},
                                               'args': [('param',
                                                         'double',
                                                         'in')],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': 'Check 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': {},
                                               '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': 'Check 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': {},
                                                        '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': 'Returns 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': {},
                                                              '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': 'Check 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': {'point': ['const',
                                                                                     '&']},
                                                        'types': {'point': 'MPoint',
                                                                  'space': ('MSpace',
                                                                            'Space'),
                                                                  'tolerance': 'double'}}],
                                  'isTrimmedSurface': [{'argInfo': {},
                                                        'args': [],
                                                        'defaults': {},
                                                        'deprecated': False,
                                                        'doc': 'This 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': {},
                                                        'types': {}}],
                                  'isUniform': [{'argInfo': {},
                                                 'args': [],
                                                 'defaults': {},
                                                 'deprecated': False,
                                                 'doc': 'Determine 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': {},
                                                 'types': {}}],
                                  'knotInU': [{'argInfo': {'index': {'doc': 'The U index of the knot value to get',
                                                                     'type': 'uint'}},
                                               'args': [('index',
                                                         'uint',
                                                         'in')],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': 'Retrieve 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': {'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': 'Retrieve 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': {'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': 'Retrieve 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': {},
                                              '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': 'Returns 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': 'uint'},
                                                     'returnType': 'uint',
                                                     'static': False,
                                                     'typeQualifiers': {'region': ['unsigned']},
                                                     'types': {'region': 'uint'}}],
                                  'numCVsInU': [{'argInfo': {},
                                                 'args': [],
                                                 'defaults': {},
                                                 'deprecated': False,
                                                 'doc': 'Returns 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': {},
                                                 'types': {}}],
                                  'numCVsInV': [{'argInfo': {},
                                                 'args': [],
                                                 'defaults': {},
                                                 'deprecated': False,
                                                 'doc': 'Returns 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': {},
                                                 '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': 'Return 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': 'uint'},
                                                'returnType': 'uint',
                                                'static': False,
                                                'typeQualifiers': {'boundary': ['unsigned'],
                                                                   'region': ['unsigned']},
                                                'types': {'boundary': 'uint',
                                                          'region': 'uint'}}],
                                  'numKnotsInU': [{'argInfo': {},
                                                   'args': [],
                                                   'defaults': {},
                                                   'deprecated': False,
                                                   'doc': 'Returns 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': {},
                                                   'types': {}}],
                                  'numKnotsInV': [{'argInfo': {},
                                                   'args': [],
                                                   'defaults': {},
                                                   'deprecated': False,
                                                   'doc': 'Returns 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': {},
                                                   'types': {}}],
                                  'numNonZeroSpansInU': [{'argInfo': {},
                                                          'args': [],
                                                          'defaults': {},
                                                          'deprecated': False,
                                                          'doc': 'Returns 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': {},
                                                          'types': {}}],
                                  'numNonZeroSpansInV': [{'argInfo': {},
                                                          'args': [],
                                                          'defaults': {},
                                                          'deprecated': False,
                                                          'doc': 'Returns 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': {},
                                                          'types': {}}],
                                  'numPatches': [{'argInfo': {},
                                                  'args': [],
                                                  'defaults': {},
                                                  'deprecated': False,
                                                  'doc': 'Returns the number of non-zero patches in this surface.',
                                                  'inArgs': [],
                                                  'outArgs': [],
                                                  'returnInfo': {'doc': 'The number of non-zero patches in this surface.',
                                                                 'qualifiers': [],
                                                                 'type': 'uint'},
                                                  'returnType': 'uint',
                                                  'static': False,
                                                  'typeQualifiers': {},
                                                  'types': {}}],
                                  'numPatchesInU': [{'argInfo': {},
                                                     'args': [],
                                                     'defaults': {},
                                                     'deprecated': False,
                                                     'doc': 'Returns 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': 'uint'},
                                                     'returnType': 'uint',
                                                     'static': False,
                                                     'typeQualifiers': {},
                                                     'types': {}}],
                                  'numPatchesInV': [{'argInfo': {},
                                                     'args': [],
                                                     'defaults': {},
                                                     'deprecated': False,
                                                     'doc': 'Returns 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': 'uint'},
                                                     'returnType': 'uint',
                                                     'static': False,
                                                     'typeQualifiers': {},
                                                     'types': {}}],
                                  'numRegions': [{'argInfo': {},
                                                  'args': [],
                                                  'defaults': {},
                                                  'deprecated': False,
                                                  'doc': 'Returns 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': 'uint'},
                                                  'returnType': 'uint',
                                                  'static': False,
                                                  'typeQualifiers': {},
                                                  'types': {}}],
                                  'numSpansInU': [{'argInfo': {},
                                                   'args': [],
                                                   'defaults': {},
                                                   'deprecated': False,
                                                   'doc': 'Returns 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': {},
                                                   'types': {}}],
                                  'numSpansInV': [{'argInfo': {},
                                                   'args': [],
                                                   'defaults': {},
                                                   'deprecated': False,
                                                   'doc': 'Returns 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': {},
                                                   'types': {}}],
                                  'numUVs': [{'argInfo': {},
                                              'args': [],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': "Returns 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': {},
                                              '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': 'Project 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': {'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': 'Remove 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': {},
                                                     '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': 'Remove 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': {},
                                                     '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': 'Remove one U knot at the specified parameter value from this surface.',
                                                        'inArgs': ['atThisParam'],
                                                        'outArgs': [],
                                                        'returnInfo': {'doc': '',
                                                                       'qualifiers': [],
                                                                       'type': None},
                                                        'returnType': None,
                                                        'static': False,
                                                        'typeQualifiers': {},
                                                        'types': {'atThisParam': 'double'}}],
                                  'removeOneKnotInV': [{'argInfo': {'atThisParam': {'doc': 'Parameter of knot to be removed',
                                                                                    'type': 'double'}},
                                                        'args': [('atThisParam',
                                                                  'double',
                                                                  'in')],
                                                        'defaults': {},
                                                        'deprecated': False,
                                                        'doc': 'Remove one V knot at the specified parameter value from this surface.',
                                                        'inArgs': ['atThisParam'],
                                                        'outArgs': [],
                                                        'returnInfo': {'doc': '',
                                                                       'qualifiers': [],
                                                                       'type': None},
                                                        'returnType': None,
                                                        'static': False,
                                                        'typeQualifiers': {},
                                                        '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': 'Set 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': ['&']},
                                             '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': 'Set 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',
                                                                           '&']},
                                              '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': [('index',
                                                            'int',
                                                            'in'),
                                                           ('param',
                                                            'double',
                                                            'in')],
                                                  'defaults': {},
                                                  'deprecated': False,
                                                  'doc': 'Set 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': ['index', 'param'],
                                                  'inverse': ('knotInU', True),
                                                  'outArgs': [],
                                                  'returnInfo': {'doc': '',
                                                                 'qualifiers': [],
                                                                 'type': None},
                                                  'returnType': None,
                                                  'static': False,
                                                  'typeQualifiers': {'index': ['unsigned']},
                                                  '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': 'Set 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']},
                                                  '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': 'Set 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': 'Set 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': 'Sets 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': {},
                                             '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': 'Sets 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': 'Performs 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': {'parms': ['&']},
                                                 'types': {'parentOrOwner': 'MObject',
                                                           'parms': 'MTesselationParams'}},
                                                {'argInfo': {'parms': {'doc': 'Tesselation parameters',
                                                                       'type': 'MTesselationParams'}},
                                                 'args': [('parms',
                                                           'MTesselationParams',
                                                           'in')],
                                                 'defaults': {},
                                                 'deprecated': True,
                                                 'doc': 'This method is obsolete. [as of Maya 2019]',
                                                 'inArgs': ['parms'],
                                                 'outArgs': [],
                                                 'returnInfo': {'doc': 'A polygonal representation of this surface',
                                                                'qualifiers': [],
                                                                'type': 'MObject'},
                                                 'returnType': 'MObject',
                                                 'static': False,
                                                 'typeQualifiers': {'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': 'Trim 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': {'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': 'This 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': {'mBoundaries': ['const',
                                                                                             '&']},
                                                          'types': {'createNewRegion': 'bool',
                                                                    'e_tol': 'double',
                                                                    'flipNormal': 'bool',
                                                                    'mBoundaries': 'MTrimBoundaryArray',
                                                                    'pe_tol': 'double'}}],
                                  'type': [{'argInfo': {},
                                            'args': [],
                                            'defaults': {},
                                            'deprecated': False,
                                            'doc': 'Function set type',
                                            'inArgs': [],
                                            'outArgs': [],
                                            'returnInfo': {'doc': 'the class type.',
                                                           'qualifiers': [],
                                                           'type': ('MFn',
                                                                    'Type')},
                                            'returnType': ('MFn', 'Type'),
                                            'static': False,
                                            'typeQualifiers': {},
                                            'types': {}}],
                                  'updateSurface': [{'argInfo': {},
                                                     'args': [],
                                                     'defaults': {},
                                                     'deprecated': False,
                                                     'doc': 'This 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': 'Returns the name of this class.',
                                                     'inArgs': [],
                                                     'outArgs': [],
                                                     'returnInfo': {'doc': 'Name of this class.',
                                                                    'qualifiers': ['*'],
                                                                    'type': 'char'},
                                                     'returnType': 'char',
                                                     'static': True,
                                                     'typeQualifiers': {},
                                                     'types': {}}],
                                      'create': [{'argInfo': {},
                                                  'args': [],
                                                  'defaults': {},
                                                  'deprecated': False,
                                                  'doc': 'Create 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': {},
                                                  'types': {}}],
                                      'type': [{'argInfo': {},
                                                'args': [],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': 'Function set type',
                                                'inArgs': [],
                                                'outArgs': [],
                                                'returnInfo': {'doc': 'the class type.',
                                                               'qualifiers': [],
                                                               'type': ('MFn',
                                                                        'Type')},
                                                'returnType': ('MFn', 'Type'),
                                                'static': False,
                                                'typeQualifiers': {},
                                                'types': {}}]},
                          'pymelEnums': {}},
  'MFnParticleSystem': {'enums': {'RenderType': {'valueDocs': {},
                                                 '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': 'To 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': 'Populates the given array with the age values of the particles in this system.',
                                             'inArgs': ['ages'],
                                             'outArgs': [],
                                             'returnInfo': {'doc': '',
                                                            'qualifiers': [],
                                                            'type': None},
                                             'returnType': None,
                                             'static': False,
                                             'typeQualifiers': {'ages': ['&']},
                                             'types': {'ages': 'MDoubleArray'}}],
                                    'betterIllum': [{'argInfo': {},
                                                     'args': [],
                                                     'defaults': {},
                                                     'deprecated': False,
                                                     'doc': 'Only 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': 'Returns whether or not the rendering attribute for particles casting shadows has been enabled.',
                                                      'inArgs': [],
                                                      'outArgs': [],
                                                      'returnInfo': {'doc': '',
                                                                     'qualifiers': [],
                                                                     'type': 'bool'},
                                                      'returnType': 'bool',
                                                      'static': False,
                                                      'typeQualifiers': {},
                                                      'types': {}}],
                                    'className': [{'argInfo': {},
                                                   'args': [],
                                                   'defaults': {},
                                                   'deprecated': False,
                                                   'doc': 'Returns the name of this class.',
                                                   'inArgs': [],
                                                   'outArgs': [],
                                                   'returnInfo': {'doc': 'Name of this class.',
                                                                  'qualifiers': ['*'],
                                                                  'type': 'char'},
                                                   'returnType': 'char',
                                                   'static': True,
                                                   'typeQualifiers': {},
                                                   'types': {}}],
                                    'count': [{'argInfo': {},
                                               'args': [],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': 'Returns the particle count at the current frame.',
                                               'inArgs': [],
                                               'inverse': ('setCount', False),
                                               'outArgs': [],
                                               'returnInfo': {'doc': '',
                                                              'qualifiers': [],
                                                              'type': 'uint'},
                                               'returnType': 'uint',
                                               'static': False,
                                               'typeQualifiers': {},
                                               'types': {}}],
                                    'create': [{'argInfo': {},
                                                'args': [],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': 'To create a new particleShape with a transform.',
                                                'inArgs': [],
                                                'outArgs': [],
                                                'returnInfo': {'doc': 'The newly created particleShape',
                                                               'qualifiers': [],
                                                               'type': 'MObject'},
                                                'returnType': 'MObject',
                                                'static': False,
                                                'typeQualifiers': {},
                                                'types': {}},
                                               {'argInfo': {'parentMObj': {'doc': 'The parent as an MObject',
                                                                           'type': 'MObject'}},
                                                'args': [('parentMObj',
                                                          'MObject',
                                                          'in')],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': 'To 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': {},
                                                'types': {'parentMObj': 'MObject'}}],
                                    'deformedParticleShape': [{'argInfo': {},
                                                               'args': [],
                                                               'defaults': {},
                                                               'deprecated': False,
                                                               'doc': 'To 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': {},
                                                               'types': {}}],
                                    'disableCloudAxis': [{'argInfo': {},
                                                          'args': [],
                                                          'defaults': {},
                                                          'deprecated': False,
                                                          'doc': 'Only 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': 'Populates the given array with the incandescence values of the particles in this system, if the particles have this attribute. See hasEmission().',
                                                  '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': 'To 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': 'To 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': 'To 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': 'To 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': 'Run 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': {'to': ['&']},
                                                          'types': {'runupFromStart': 'bool',
                                                                    'to': 'MTime'}}],
                                    'flatShaded': [{'argInfo': {},
                                                    'args': [],
                                                    'defaults': {},
                                                    'deprecated': False,
                                                    'doc': 'To 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': 'true The particles are displayed as flat shaded discs false The particles are displayed as volumetric dics',
                                                                   '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': 'To 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': 'uint'},
                                                                 'returnType': 'uint',
                                                                 'static': False,
                                                                 'typeQualifiers': {'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': 'To 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': 'uint'},
                                                                 'returnType': 'uint',
                                                                 'static': False,
                                                                 'typeQualifiers': {'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': 'To 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': 'uint'},
                                                                 'returnType': 'uint',
                                                                 'static': False,
                                                                 'typeQualifiers': {'array': ['&'],
                                                                                    'attrName': ['const',
                                                                                                 '&']},
                                                                 'types': {'array': 'MDoubleArray',
                                                                           'attrName': 'MString'}}],
                                    'hasEmission': [{'argInfo': {},
                                                     'args': [],
                                                     'defaults': {},
                                                     'deprecated': False,
                                                     'doc': 'Returns whether or not the particles in this system have an emission attribute. See emission().',
                                                     'inArgs': [],
                                                     'outArgs': [],
                                                     'returnInfo': {'doc': '',
                                                                    'qualifiers': [],
                                                                    'type': 'bool'},
                                                     'returnType': 'bool',
                                                     'static': False,
                                                     'typeQualifiers': {},
                                                     'types': {}}],
                                    'hasLifespan': [{'argInfo': {},
                                                     'args': [],
                                                     'defaults': {},
                                                     'deprecated': False,
                                                     'doc': 'Returns whether or not the particles in this system have a lifespan attribute. See lifespan().',
                                                     'inArgs': [],
                                                     'outArgs': [],
                                                     'returnInfo': {'doc': '',
                                                                    'qualifiers': [],
                                                                    'type': 'bool'},
                                                     'returnType': 'bool',
                                                     'static': False,
                                                     'typeQualifiers': {},
                                                     'types': {}}],
                                    'hasOpacity': [{'argInfo': {},
                                                    'args': [],
                                                    'defaults': {},
                                                    'deprecated': False,
                                                    'doc': 'Returns whether or not the particles in this system have an opacity attribute. See opacity().',
                                                    'inArgs': [],
                                                    'outArgs': [],
                                                    'returnInfo': {'doc': '',
                                                                   'qualifiers': [],
                                                                   'type': 'bool'},
                                                    'returnType': 'bool',
                                                    'static': False,
                                                    'typeQualifiers': {},
                                                    'types': {}}],
                                    'hasRgb': [{'argInfo': {},
                                                'args': [],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': 'Returns whether or not the particles in this system have an rgb attribute. See rgb().',
                                                'inArgs': [],
                                                'outArgs': [],
                                                'returnInfo': {'doc': '',
                                                               'qualifiers': [],
                                                               'type': 'bool'},
                                                'returnType': 'bool',
                                                'static': False,
                                                'typeQualifiers': {},
                                                'types': {}}],
                                    'isDeformedParticleShape': [{'argInfo': {},
                                                                 'args': [],
                                                                 'defaults': {},
                                                                 'deprecated': False,
                                                                 'doc': 'To 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': {},
                                                                 'types': {}}],
                                    'isPerParticleDoubleAttribute': [{'argInfo': {'attrName': {'doc': 'The input attribute name',
                                                                                               'type': 'MString'}},
                                                                      'args': [('attrName',
                                                                                'MString',
                                                                                'in')],
                                                                      'defaults': {},
                                                                      'deprecated': False,
                                                                      'doc': 'To check if the input attribute is a per particle double attribute.',
                                                                      'inArgs': ['attrName'],
                                                                      'outArgs': [],
                                                                      'returnInfo': {'doc': '',
                                                                                     'qualifiers': [],
                                                                                     'type': 'bool'},
                                                                      'returnType': 'bool',
                                                                      'static': False,
                                                                      'typeQualifiers': {'attrName': ['const',
                                                                                                      '&']},
                                                                      'types': {'attrName': 'MString'}}],
                                    'isPerParticleIntAttribute': [{'argInfo': {'attrName': {'doc': 'The input attribute name',
                                                                                            'type': 'MString'}},
                                                                   'args': [('attrName',
                                                                             'MString',
                                                                             'in')],
                                                                   'defaults': {},
                                                                   'deprecated': False,
                                                                   'doc': 'To check if the input attribute is a per particle integer attribute.',
                                                                   'inArgs': ['attrName'],
                                                                   'outArgs': [],
                                                                   'returnInfo': {'doc': '',
                                                                                  'qualifiers': [],
                                                                                  'type': 'bool'},
                                                                   'returnType': 'bool',
                                                                   'static': False,
                                                                   'typeQualifiers': {'attrName': ['const',
                                                                                                   '&']},
                                                                   'types': {'attrName': 'MString'}}],
                                    'isPerParticleVectorAttribute': [{'argInfo': {'attrName': {'doc': 'The input attribute name',
                                                                                               'type': 'MString'}},
                                                                      'args': [('attrName',
                                                                                'MString',
                                                                                'in')],
                                                                      'defaults': {},
                                                                      'deprecated': False,
                                                                      'doc': 'To check if the input attribute is a per particle vector attribute.',
                                                                      'inArgs': ['attrName'],
                                                                      'outArgs': [],
                                                                      'returnInfo': {'doc': '',
                                                                                     'qualifiers': [],
                                                                                     'type': 'bool'},
                                                                      'returnType': 'bool',
                                                                      'static': False,
                                                                      'typeQualifiers': {'attrName': ['const',
                                                                                                      '&']},
                                                                      'types': {'attrName': 'MString'}}],
                                    'isValid': [{'argInfo': {},
                                                 'args': [],
                                                 'defaults': {},
                                                 'deprecated': False,
                                                 'doc': 'Returns 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': 'Populates the given array with the lifespan values of the particles in this system, if the particles have this attribute. See hasLifespan().',
                                                  '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': 'To 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': 'Populates the given array with the opacity values of the particles in this system, if the particles have this attribute. See hasOpacity().',
                                                 'inArgs': ['opacities'],
                                                 'outArgs': [],
                                                 'returnInfo': {'doc': '',
                                                                'qualifiers': [],
                                                                'type': None},
                                                 'returnType': None,
                                                 'static': False,
                                                 'typeQualifiers': {'opacities': ['&']},
                                                 'types': {'opacities': 'MDoubleArray'}}],
                                    'originalParticleShape': [{'argInfo': {},
                                                               'args': [],
                                                               'defaults': {},
                                                               'deprecated': False,
                                                               'doc': 'To 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': {},
                                                               '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': "Return 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': 'Returns the name of this particle system.',
                                                      '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': "Compute 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': 'Only 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': 'Only 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': 'Returns whether or not the rendering attribute for primary visibility in reflections has been enabled.',
                                                           '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': 'Calculates 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': 'Only 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': 'Only 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': 'Returns whether or not the rendering attribute for particles receiving shadows has been enabled.',
                                                        'inArgs': [],
                                                        'outArgs': [],
                                                        'returnInfo': {'doc': '',
                                                                       'qualifiers': [],
                                                                       'type': 'bool'},
                                                        'returnType': 'bool',
                                                        'static': False,
                                                        'typeQualifiers': {},
                                                        'types': {}}],
                                    'renderType': [{'argInfo': {},
                                                    'args': [],
                                                    'defaults': {},
                                                    'deprecated': False,
                                                    'doc': 'Return the render type used by the particle object.',
                                                    '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': 'Populates 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': "To 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': 'Set 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': 'To 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': {'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': 'To 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': {'array': ['&'],
                                                                                    'attrName': ['const',
                                                                                                 '&']},
                                                                 'types': {'array': 'MDoubleArray',
                                                                           'attrName': 'MString'}}],
                                    'surfaceShading': [{'argInfo': {},
                                                        'args': [],
                                                        'defaults': {},
                                                        'deprecated': False,
                                                        'doc': 'Only 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': 'Only 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': 'Only 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': 'Function set type',
                                              'inArgs': [],
                                              'outArgs': [],
                                              'returnInfo': {'doc': 'the class type.',
                                                             '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': 'To 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': 'Returns whether or not the rendering attribute for particle visibility in reflections has been enabled.',
                                                              'inArgs': [],
                                                              'outArgs': [],
                                                              'returnInfo': {'doc': '',
                                                                             'qualifiers': [],
                                                                             'type': 'bool'},
                                                              'returnType': 'bool',
                                                              'static': False,
                                                              'typeQualifiers': {},
                                                              'types': {}}],
                                    'visibleInRefractions': [{'argInfo': {},
                                                              'args': [],
                                                              'defaults': {},
                                                              'deprecated': False,
                                                              'doc': 'Returns whether or not the rendering attribute for particle visibility in refractions has been enabled.',
                                                              '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': {'Restriction': {'valueDocs': {},
                                             'values': "Enum('Restriction', {'kNone': 0, 'kVerticesOnly': 1, 'kEdgesOnly': 2, 'kFacetsOnly': 3, 'kEditPointsOnly': 4, 'kRenderableOnly': 5})"}},
                   'methods': {'addMember': [{'argInfo': {'set': {'doc': 'new set to be added to this partiton.',
                                                                  'type': 'MObject'}},
                                              'args': [('set',
                                                        'MObject',
                                                        'in')],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': 'Add 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': 'Returns the name of this class.',
                                              'inArgs': [],
                                              'outArgs': [],
                                              'returnInfo': {'doc': 'Name of this class.',
                                                             'qualifiers': ['*'],
                                                             'type': 'char'},
                                              'returnType': 'char',
                                              'static': True,
                                              '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': 'Creates 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': {},
                                           'types': {'isRenderPartition': 'bool'}}],
                               'isRenderPartition': [{'argInfo': {},
                                                      'args': [],
                                                      'defaults': {},
                                                      'deprecated': False,
                                                      'doc': 'Returns 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': {},
                                                      'types': {}}],
                               'removeMember': [{'argInfo': {'set': {'doc': 'old set to be removed from this partiton.',
                                                                     'type': 'MObject'}},
                                                 'args': [('set',
                                                           'MObject',
                                                           'in')],
                                                 'defaults': {},
                                                 'deprecated': False,
                                                 'doc': 'Remove 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': 'Function set type',
                                         'inArgs': [],
                                         'outArgs': [],
                                         'returnInfo': {'doc': 'the class type.',
                                                        '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)"}},
  'MFnPfxGeometry': {'enums': {},
                     'methods': {'className': [{'argInfo': {},
                                                'args': [],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': 'Returns the name of this class.',
                                                'inArgs': [],
                                                'outArgs': [],
                                                'returnInfo': {'doc': 'Name of this class.',
                                                               'qualifiers': ['*'],
                                                               'type': 'char'},
                                                'returnType': 'char',
                                                'static': True,
                                                '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': 'Gets 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': 'Get 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': {'flowerLines': ['&'],
                                                                     'leafLines': ['&'],
                                                                     'mainLines': ['&']},
                                                  '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': 'Function set type',
                                           'inArgs': [],
                                           'outArgs': [],
                                           'returnInfo': {'doc': 'the class type.',
                                                          'qualifiers': [],
                                                          'type': ('MFn',
                                                                   'Type')},
                                           'returnType': ('MFn', 'Type'),
                                           'static': False,
                                           'typeQualifiers': {},
                                           'types': {}}]},
                     'pymelEnums': {}},
  'MFnPhongEShader': {'enums': {},
                      'invertibles': [('setHighlightSize', 'highlightSize'),
                                      ('setRoughness', 'roughness'),
                                      ('setWhiteness', 'whiteness')],
                      'methods': {'className': [{'argInfo': {},
                                                 'args': [],
                                                 'defaults': {},
                                                 'deprecated': False,
                                                 'doc': 'Returns the name of this class.',
                                                 'inArgs': [],
                                                 'outArgs': [],
                                                 'returnInfo': {'doc': 'Name of this class.',
                                                                'qualifiers': ['*'],
                                                                'type': 'char'},
                                                 'returnType': 'char',
                                                 'static': True,
                                                 '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': 'Creates 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': {},
                                              'types': {'UIvisible': 'bool'}}],
                                  'highlightSize': [{'argInfo': {},
                                                     'args': [],
                                                     'defaults': {},
                                                     'deprecated': False,
                                                     'doc': 'Retrieves 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': {},
                                                     'types': {}}],
                                  'roughness': [{'argInfo': {},
                                                 'args': [],
                                                 'defaults': {},
                                                 'deprecated': False,
                                                 'doc': 'Retrieves 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': {},
                                                 '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': 'Sets 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': 'Sets 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': 'Sets 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': 'Function set type',
                                            'inArgs': [],
                                            'outArgs': [],
                                            'returnInfo': {'doc': 'the class type.',
                                                           'qualifiers': [],
                                                           'type': ('MFn',
                                                                    'Type')},
                                            'returnType': ('MFn', 'Type'),
                                            'static': False,
                                            'typeQualifiers': {},
                                            'types': {}}],
                                  'whiteness': [{'argInfo': {},
                                                 'args': [],
                                                 'defaults': {},
                                                 'deprecated': False,
                                                 'doc': 'Retrieves 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': {},
                                                 'types': {}}]},
                      'pymelEnums': {},
                      'pymelMethods': {'highlightSize': 'getHighlightSize',
                                       'roughness': 'getRoughness',
                                       'whiteness': 'getWhiteness'}},
  'MFnPhongShader': {'enums': {},
                     'invertibles': [('setCosPower', 'cosPower')],
                     'methods': {'className': [{'argInfo': {},
                                                'args': [],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': 'Returns the name of this class.',
                                                'inArgs': [],
                                                'outArgs': [],
                                                'returnInfo': {'doc': 'Name of this class.',
                                                               'qualifiers': ['*'],
                                                               'type': 'char'},
                                                'returnType': 'char',
                                                'static': True,
                                                'typeQualifiers': {},
                                                'types': {}}],
                                 'cosPower': [{'argInfo': {},
                                               'args': [],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': 'Retrieves 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': {},
                                               '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': 'Creates 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': {},
                                             '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': 'Sets 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': 'Function set type',
                                           'inArgs': [],
                                           'outArgs': [],
                                           'returnInfo': {'doc': 'the class type.',
                                                          'qualifiers': [],
                                                          'type': ('MFn',
                                                                   'Type')},
                                           'returnType': ('MFn', 'Type'),
                                           'static': False,
                                           'typeQualifiers': {},
                                           'types': {}}]},
                     'pymelEnums': {},
                     'pymelMethods': {'cosPower': 'getCosPower'}},
  'MFnPlugin': {'enums': {'ImageFilePriority': {'valueDocs': {},
                                                'values': "Enum('ImageFilePriority', [('kImageFilePriorityHighest', 0), ('kImageFilePriorityHigh', 10), ('kImageFilePriorityDefault', 10), ('kImageFilePriorityLow', 20), ('kImageFilePriorityLowest', 30)], multiKeys=True)"}},
                'invertibles': [('setCallableInfo', 'getCallableInfo'),
                                ('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. It must be 7bit ASCII.',
                                                                          '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': True,
                                             'doc': 'This method is obsolete. [as of Maya 2022]',
                                             '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',
                                                                                 '&'],
                                                                'optBoxFunction': ['const',
                                                                                   '*'],
                                                                'parentName': ['const',
                                                                               '&']},
                                             'types': {'commandName': 'MString',
                                                       'commandParams': 'MString',
                                                       'extraMenuItemParams': 'MString',
                                                       'menuItemName': 'MString',
                                                       'needOptionBox': 'bool',
                                                       'optBoxFunction': 'MString',
                                                       'parentName': 'MString'}},
                                            {'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'},
                                                         'menuItemLabel': {'doc': 'This will be used as the label for the menuItem.',
                                                                           'type': 'MString'},
                                                         'menuItemName': {'doc': 'This will be used as the name for the menuItem. It must be 7bit ASCII.',
                                                                          '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'),
                                                      ('menuItemLabel',
                                                       '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': 'The 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',
                                                        'menuItemLabel',
                                                        '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',
                                                                                        '*'],
                                                                'menuItemLabel': ['const',
                                                                                  '&'],
                                                                'menuItemName': ['const',
                                                                                 '&'],
                                                                'optBoxFunction': ['const',
                                                                                   '*'],
                                                                'parentName': ['const',
                                                                               '&']},
                                             'types': {'commandName': 'MString',
                                                       'commandParams': 'MString',
                                                       'extraMenuItemParams': 'MString',
                                                       'menuItemLabel': 'MString',
                                                       'menuItemName': 'MString',
                                                       'needOptionBox': 'bool',
                                                       'optBoxFunction': 'MString',
                                                       'parentName': 'MString'}}],
                            'apiVersion': [{'argInfo': {},
                                            'args': [],
                                            'defaults': {},
                                            'deprecated': False,
                                            'doc': 'Return 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': {},
                                            'types': {}}],
                            'className': [{'argInfo': {},
                                           'args': [],
                                           'defaults': {},
                                           'deprecated': False,
                                           'doc': 'Returns the name of this class.',
                                           'inArgs': [],
                                           'outArgs': [],
                                           'returnInfo': {'doc': 'Name of this class.',
                                                          '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': 'Deregister 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': 'Deregister 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': 'Deregister 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': 'Deregister 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': 'Deregister 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': 'Deregister 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': 'Deregister 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': 'Deregister 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': 'Deregister 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': 'Deregister 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': 'Deregister 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': 'Deregister 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': 'Deregister 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': 'Deregister 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': 'Deregister 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': 'Deregister 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': 'Deregister 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': 'Deregister 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': 'Deregister 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': 'Deregisters an renderer identified by name.',
                                                    'inArgs': ['name'],
                                                    'outArgs': [],
                                                    'returnInfo': {'doc': '',
                                                                   'qualifiers': [],
                                                                   'type': None},
                                                    'returnType': None,
                                                    'static': False,
                                                    'typeQualifiers': {'name': ['const',
                                                                                '&']},
                                                    'types': {'name': 'MString'}}],
                            'deregisterTopologyEvaluator': [{'argInfo': {'evaluatorName': {'doc': 'the name of the evaluator.',
                                                                                           'type': 'MString'}},
                                                             'args': [('evaluatorName',
                                                                       'MString',
                                                                       'in')],
                                                             'defaults': {},
                                                             'deprecated': False,
                                                             'doc': 'Deregister 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'}}],
                            'deregisterURIFileResolver': [{'argInfo': {'fileResolverName': {'doc': 'the name of the file resolver to deregister',
                                                                                            'type': 'MString'}},
                                                           'args': [('fileResolverName',
                                                                     'MString',
                                                                     'in')],
                                                           'defaults': {},
                                                           'deprecated': False,
                                                           'doc': 'Deregister 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': "Returns 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'}}],
                            'getCallableInfo': [{'argInfo': {},
                                                 'args': [],
                                                 'defaults': {},
                                                 'deprecated': False,
                                                 'doc': 'Get callback info to be passed as ClientData to scripts.',
                                                 'inArgs': [],
                                                 'inverse': ('setCallableInfo',
                                                             False),
                                                 'outArgs': [],
                                                 'returnInfo': {'doc': '',
                                                                'qualifiers': ['*'],
                                                                'type': ('MFnPlugin',
                                                                         'MPluginCallableInfo')},
                                                 'returnType': ('MFnPlugin',
                                                                'MPluginCallableInfo'),
                                                 'static': False,
                                                 'typeQualifiers': {},
                                                 'types': {}}],
                            'isNodeRegistered': [{'argInfo': {'typeName': {'doc': 'the type name of a depend graph node to query.',
                                                                           'type': 'MString'}},
                                                  'args': [('typeName',
                                                            'MString',
                                                            'in')],
                                                  'defaults': {},
                                                  'deprecated': False,
                                                  'doc': 'Queries 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': 'Determine 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': {},
                                          'types': {}}],
                            'matrixTypeIdFromXformId': [{'argInfo': {'xformTypeId': {'doc': 'the typeId of the transform.',
                                                                                     'type': 'MTypeId'}},
                                                         'args': [('xformTypeId',
                                                                   'MTypeId',
                                                                   'in')],
                                                         'defaults': {},
                                                         'deprecated': False,
                                                         'doc': 'The 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': {'xformTypeId': ['const',
                                                                                            '&']},
                                                         'types': {'xformTypeId': 'MTypeId'}}],
                            'name': [{'argInfo': {},
                                      'args': [],
                                      'defaults': {},
                                      'deprecated': False,
                                      'doc': 'Return 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': {},
                                      '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': 'Register 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': {'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': 'Registers a new attribute pattern factory type with Maya.',
                                                                 'inArgs': ['patternFactoryName',
                                                                            'creatorFunction'],
                                                                 'outArgs': [],
                                                                 'returnInfo': {'doc': '',
                                                                                'qualifiers': [],
                                                                                'type': None},
                                                                 'returnType': None,
                                                                 'static': False,
                                                                 'typeQualifiers': {'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': 'Registers a new bake engine type with Maya.',
                                                    'inArgs': ['bakeEngineGenName',
                                                               'fnPtr'],
                                                    'outArgs': [],
                                                    'returnInfo': {'doc': '',
                                                                   'qualifiers': [],
                                                                   'type': None},
                                                    'returnType': None,
                                                    'static': False,
                                                    'typeQualifiers': {'bakeEngineGenName': ['const',
                                                                                             '&']},
                                                    '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': 'Register a new cache format with Maya.',
                                                     'inArgs': ['cacheFormatName',
                                                                'creatorFunction'],
                                                     'outArgs': [],
                                                     'returnInfo': {'doc': '',
                                                                    'qualifiers': [],
                                                                    'type': None},
                                                     'returnType': None,
                                                     'static': False,
                                                     'typeQualifiers': {'cacheFormatName': ['const',
                                                                                            '&']},
                                                     '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': 'Register 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',
                                                                                    '&']},
                                                 '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': 'Register 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',
                                                                                              '&']},
                                                           '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': 'Register 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',
                                                                                           '&']},
                                                        '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 MPxContextCommand) 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': 'Register 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',
                                                                                           '&'],
                                                                           'toolCmdName': ['const',
                                                                                           '&']},
                                                        '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': 'Register 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',
                                                                                           '&']},
                                                        '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': 'Register 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': {'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': 'Register 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': {'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': 'Register 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': 'Register 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',
                                                                                                 '&']},
                                                             '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',
                                                                                            'MCustomEvaluatorCreatorFunction')},
                                                               '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',
                                                              'MCustomEvaluatorCreatorFunction'),
                                                             'in')],
                                                   'defaults': {},
                                                   'deprecated': False,
                                                   'doc': 'Register 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': {'evaluatorName': ['const',
                                                                                        '&'],
                                                                      'uniquePriority': ['unsigned']},
                                                   'types': {'creatorFunction': ('MFnPlugin',
                                                                                 'MCustomEvaluatorCreatorFunction'),
                                                             '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': 'Register 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': {'defaultOptionsString': ['const',
                                                                                                    '*'],
                                                                           'optionsScriptName': ['const',
                                                                                                 '*'],
                                                                           'pixmapName': ['const',
                                                                                          '*'],
                                                                           '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': 'Register 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': {'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'},
                                                               'priority': {'doc': 'Priority number that allow user to specify the plugin priority. The higher the number is, the lower the priority is. High priority plugin will be use before Maya internal code and low priority plugin will be use after Maya internal code.',
                                                                            'type': ('MFnPlugin',
                                                                                     'ImageFilePriority')}},
                                                   'args': [('imageFormatName',
                                                             'MString',
                                                             'in'),
                                                            ('creatorFunction',
                                                             ('MFnPlugin',
                                                              'MCreatorFunction'),
                                                             'in'),
                                                            ('imageFileExtensions',
                                                             'MStringArray',
                                                             'in'),
                                                            ('priority',
                                                             ('MFnPlugin',
                                                              'ImageFilePriority'),
                                                             'in')],
                                                   'defaults': {'priority': ('MFnPlugin',
                                                                             'ImageFilePriority',
                                                                             'kImageFilePriorityDefault')},
                                                   'deprecated': False,
                                                   'doc': 'Register a new image file translator with Maya.',
                                                   'inArgs': ['imageFormatName',
                                                              'creatorFunction',
                                                              'imageFileExtensions',
                                                              'priority'],
                                                   'outArgs': [],
                                                   'returnInfo': {'doc': '',
                                                                  'qualifiers': [],
                                                                  'type': None},
                                                   'returnType': None,
                                                   'static': False,
                                                   'typeQualifiers': {'imageFileExtensions': ['const',
                                                                                              '&'],
                                                                      'imageFormatName': ['const',
                                                                                          '&']},
                                                   'types': {'creatorFunction': ('MFnPlugin',
                                                                                 'MCreatorFunction'),
                                                             'imageFileExtensions': 'MStringArray',
                                                             'imageFormatName': 'MString',
                                                             'priority': ('MFnPlugin',
                                                                          'ImageFilePriority')}}],
                            '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': 'Registers a new material information type with Maya.',
                                                      'inArgs': ['materialInfoName',
                                                                 'fnPtr'],
                                                      'outArgs': [],
                                                      'returnInfo': {'doc': '',
                                                                     'qualifiers': [],
                                                                     'type': None},
                                                      'returnType': None,
                                                      'static': False,
                                                      'typeQualifiers': {'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': 'Register 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',
                                                                                               '&']},
                                                            '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': 'Register 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',
                                                                                    '*'],
                                                                 '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': 'Register 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': {'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': 'Registers a new renderer identified by name.',
                                                  'inArgs': ['name',
                                                             'creatorFunction'],
                                                  'outArgs': [],
                                                  'returnInfo': {'doc': '',
                                                                 'qualifiers': [],
                                                                 'type': None},
                                                  'returnType': None,
                                                  'static': False,
                                                  'typeQualifiers': {'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': 'Registers 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',
                                                                                     '*'],
                                                                  'typeId': ['const',
                                                                             '&'],
                                                                  'typeName': ['const',
                                                                               '&']},
                                               'types': {'classification': 'MString',
                                                         'creatorFunction': ('MFnPlugin',
                                                                             'MCreatorFunction'),
                                                         'initFunction': ('MFnPlugin',
                                                                          'MInitializeFunction'),
                                                         'typeId': 'MTypeId',
                                                         'typeName': 'MString',
                                                         'uiCreatorFunction': ('MFnPlugin',
                                                                               'MCreatorFunction')}}],
                            'registerTopologyEvaluator': [{'argInfo': {'creatorFunction': {'doc': 'a pointer to a function that will return a pointer to a new instance of the evaluator',
                                                                                           'type': ('MFnPlugin',
                                                                                                    'MTopologyEvaluatorCreatorFunction')},
                                                                       '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',
                                                                      'MTopologyEvaluatorCreatorFunction'),
                                                                     'in')],
                                                           'defaults': {},
                                                           'deprecated': False,
                                                           'doc': 'Register 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': {'evaluatorName': ['const',
                                                                                                '&'],
                                                                              'uniquePriority': ['unsigned']},
                                                           'types': {'creatorFunction': ('MFnPlugin',
                                                                                         'MTopologyEvaluatorCreatorFunction'),
                                                                     'evaluatorName': 'MString',
                                                                     'uniquePriority': 'uint'}}],
                            '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': 'Registers 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',
                                                                                         '*'],
                                                                      'typeId': ['const',
                                                                                 '&'],
                                                                      'typeName': ['const',
                                                                                   '&'],
                                                                      'xformId': ['const',
                                                                                  '&']},
                                                   'types': {'classification': 'MString',
                                                             'creatorFunction': ('MFnPlugin',
                                                                                 'MCreatorFunction'),
                                                             'initFunction': ('MFnPlugin',
                                                                              'MInitializeFunction'),
                                                             'typeId': 'MTypeId',
                                                             'typeName': 'MString',
                                                             'xformCreatorFunction': ('MFnPlugin',
                                                                                      'MCreateXformMatrixFunction'),
                                                             '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': 'Sets 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')}}],
                            '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': 'Set 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',
                                                                                            '&']},
                                                   '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': 'Register a Custom URI File Resolver with Maya.',
                                                         'inArgs': ['fileResolverName',
                                                                    'uriScheme',
                                                                    'creatorFunction'],
                                                         'outArgs': [],
                                                         'returnInfo': {'doc': '',
                                                                        'qualifiers': [],
                                                                        'type': None},
                                                         'returnType': None,
                                                         'static': False,
                                                         'typeQualifiers': {'fileResolverName': ['const',
                                                                                                 '&'],
                                                                            'uriScheme': ['const',
                                                                                          '&']},
                                                         'types': {'creatorFunction': ('MFnPlugin',
                                                                                       'MCreatorFunction'),
                                                                   'fileResolverName': 'MString',
                                                                   'uriScheme': 'MString'}}],
                            'registeringCallableScript': [{'argInfo': {},
                                                           'args': [],
                                                           'defaults': {},
                                                           'deprecated': False,
                                                           'doc': 'Return true if this MFnPlugin object has its callbacks defined in script.',
                                                           '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': 'The 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'}}],
                            'setCallableInfo': [{'argInfo': {'info': {'doc': '',
                                                                      'type': ('MFnPlugin',
                                                                               'MPluginCallableInfo')}},
                                                 'args': [('info',
                                                           ('MFnPlugin',
                                                            'MPluginCallableInfo'),
                                                           'in')],
                                                 'defaults': {},
                                                 'deprecated': False,
                                                 'doc': 'Set callback info to be passed as ClientData to scripts.',
                                                 'inArgs': ['info'],
                                                 'inverse': ('getCallableInfo',
                                                             True),
                                                 'outArgs': [],
                                                 'returnInfo': {'doc': '',
                                                                'qualifiers': [],
                                                                'type': None},
                                                 'returnType': None,
                                                 'static': False,
                                                 'typeQualifiers': {'info': ['*']},
                                                 'types': {'info': ('MFnPlugin',
                                                                    'MPluginCallableInfo')}}],
                            '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': 'Set 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': {'newName': ['const',
                                                                        '&']},
                                         'types': {'makeUnique': 'bool',
                                                   'newName': 'MString'}}],
                            'setPythonAPI20ValueToObjectFunction': [{'argInfo': {'fnPtr': {'doc': '',
                                                                                           'type': ('MFnPlugin',
                                                                                                    'MPythonAPI20ValueToObjectFunction')}},
                                                                     'args': [('fnPtr',
                                                                               ('MFnPlugin',
                                                                                'MPythonAPI20ValueToObjectFunction'),
                                                                               'in')],
                                                                     'defaults': {},
                                                                     'deprecated': False,
                                                                     'doc': '',
                                                                     'inArgs': ['fnPtr'],
                                                                     'outArgs': [],
                                                                     'returnInfo': {'doc': '',
                                                                                    'qualifiers': [],
                                                                                    'type': None},
                                                                     'returnType': None,
                                                                     'static': True,
                                                                     'typeQualifiers': {},
                                                                     'types': {'fnPtr': ('MFnPlugin',
                                                                                         'MPythonAPI20ValueToObjectFunction')}}],
                            'setRegisteringCallableScript': [{'argInfo': {},
                                                              'args': [],
                                                              'defaults': {},
                                                              'deprecated': False,
                                                              'doc': 'Mark this MFnPlugin object as one that will be passed callbacks defined in script.',
                                                              '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': 'Set 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': 'Return the type of this function set.',
                                      'inArgs': [],
                                      'outArgs': [],
                                      'returnInfo': {'doc': 'The constant MFn::kPlugin',
                                                     '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': 'Deregister 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': 'Deregister 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': 'Return 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': {},
                                        'types': {}}],
                            'version': [{'argInfo': {},
                                         'args': [],
                                         'defaults': {},
                                         'deprecated': False,
                                         'doc': 'Return 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': {},
                                         'types': {}}]},
                'pymelEnums': {'ImageFilePriority': "Enum('ImageFilePriority', [('highest', 0), ('kImageFilePriorityHighest', 0), ('high', 10), ('default', 10), ('kImageFilePriorityDefault', 10), ('kImageFilePriorityHigh', 10), ('low', 20), ('kImageFilePriorityLow', 20), ('lowest', 30), ('kImageFilePriorityLowest', 30)], multiKeys=True)"},
                'pymelMethods': {'name': 'getName',
                                 'registeringCallableScript': 'getRegisteringCallableScript',
                                 'version': 'getVersion'}},
  'MFnPluginData': {'enums': {},
                    'methods': {'className': [{'argInfo': {},
                                               'args': [],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': 'Returns the name of this class.',
                                               'inArgs': [],
                                               'outArgs': [],
                                               'returnInfo': {'doc': 'Name of this class.',
                                                              'qualifiers': ['*'],
                                                              'type': 'char'},
                                               'returnType': 'char',
                                               'static': True,
                                               'typeQualifiers': {},
                                               'types': {}}],
                                'constData': [{'argInfo': {},
                                               'args': [],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': 'Return 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': {},
                                               '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': 'Create 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': {'id': ['const',
                                                                      '&']},
                                            'types': {'id': 'MTypeId'}}],
                                'data': [{'argInfo': {},
                                          'args': [],
                                          'defaults': {},
                                          'deprecated': False,
                                          'doc': 'Return 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': {},
                                          'types': {}}],
                                'type': [{'argInfo': {},
                                          'args': [],
                                          'defaults': {},
                                          'deprecated': False,
                                          'doc': 'Function set type',
                                          'inArgs': [],
                                          'outArgs': [],
                                          'returnInfo': {'doc': 'the class type.',
                                                         'qualifiers': [],
                                                         'type': ('MFn',
                                                                  'Type')},
                                          'returnType': ('MFn', 'Type'),
                                          'static': False,
                                          'typeQualifiers': {},
                                          'types': {}}],
                                'typeId': [{'argInfo': {},
                                            'args': [],
                                            'defaults': {},
                                            'deprecated': False,
                                            'doc': 'Return 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': {},
                                            'types': {}}]},
                    'pymelEnums': {}},
  'MFnPointArrayData': {'enums': {},
                        'methods': {'array': [{'argInfo': {},
                                               'args': [],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': 'Get 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': {},
                                               'types': {}}],
                                    'className': [{'argInfo': {},
                                                   'args': [],
                                                   'defaults': {},
                                                   'deprecated': False,
                                                   'doc': 'Returns the name of this class.',
                                                   'inArgs': [],
                                                   'outArgs': [],
                                                   'returnInfo': {'doc': 'Name of this class.',
                                                                  'qualifiers': ['*'],
                                                                  'type': 'char'},
                                                   'returnType': 'char',
                                                   'static': True,
                                                   'typeQualifiers': {},
                                                   'types': {}}],
                                    'copyTo': [{'argInfo': {'dest': {'doc': 'the MPointArray to populate',
                                                                     'type': 'MPointArray'}},
                                                'args': [('dest',
                                                          'MPointArray',
                                                          'out')],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': 'Copy 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': 'Create 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': {},
                                                'types': {}},
                                               {'argInfo': {'arr': {'doc': 'the data to use when initializing this instance',
                                                                    'type': 'MPointArray'}},
                                                'args': [('arr',
                                                          'MPointArray',
                                                          'in')],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': 'Create 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': {'arr': ['const',
                                                                           '&']},
                                                'types': {'arr': 'MPointArray'}}],
                                    'length': [{'argInfo': {},
                                                'args': [],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': 'Return the number of points in the instance.',
                                                'inArgs': [],
                                                'outArgs': [],
                                                'returnInfo': {'doc': 'The number of points in the instance',
                                                               'qualifiers': [],
                                                               'type': 'uint'},
                                                'returnType': 'uint',
                                                'static': False,
                                                'typeQualifiers': {},
                                                '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': 'Set 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': 'Set 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': 'Function set type',
                                              'inArgs': [],
                                              'outArgs': [],
                                              'returnInfo': {'doc': 'the class type.',
                                                             'qualifiers': [],
                                                             'type': ('MFn',
                                                                      'Type')},
                                              'returnType': ('MFn', 'Type'),
                                              'static': False,
                                              'typeQualifiers': {},
                                              'types': {}}]},
                        'pymelEnums': {}},
  'MFnPointLight': {'enums': {},
                    'methods': {'className': [{'argInfo': {},
                                               'args': [],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': 'Returns the name of this class.',
                                               'inArgs': [],
                                               'outArgs': [],
                                               'returnInfo': {'doc': 'Name of this class.',
                                                              'qualifiers': ['*'],
                                                              'type': 'char'},
                                               'returnType': 'char',
                                               'static': True,
                                               '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': 'Creates 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': {},
                                            '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': 'Creates 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': {'parent': ['const',
                                                                          '&']},
                                            'types': {'UIvisible': 'bool',
                                                      'parent': 'MObject',
                                                      'wantTransform': 'bool'}}],
                                'type': [{'argInfo': {},
                                          'args': [],
                                          'defaults': {},
                                          'deprecated': False,
                                          'doc': 'Function set type',
                                          'inArgs': [],
                                          'outArgs': [],
                                          'returnInfo': {'doc': 'the class type.',
                                                         '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': 'Returns the name of this class.',
                                                      'inArgs': [],
                                                      'outArgs': [],
                                                      'returnInfo': {'doc': 'Name of this class.',
                                                                     'qualifiers': ['*'],
                                                                     'type': 'char'},
                                                      'returnType': 'char',
                                                      'static': True,
                                                      'typeQualifiers': {},
                                                      'types': {}}],
                                       'connectToCurvePlug': [{'argInfo': {'curvePlug': {'doc': 'the curve plug',
                                                                                         'type': 'MPlug'}},
                                                               'args': [('curvePlug',
                                                                         'MPlug',
                                                                         'in')],
                                                               'defaults': {},
                                                               'deprecated': False,
                                                               'doc': 'Connect 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': 'Connect 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': "Creates 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': {},
                                                   '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': "Creates 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': {'manipName': ['const',
                                                                                    '&'],
                                                                      'paramName': ['const',
                                                                                    '&']},
                                                   'types': {'manipName': 'MString',
                                                             'paramName': 'MString'}}],
                                       'curveIndex': [{'argInfo': {},
                                                       'args': [],
                                                       'defaults': {},
                                                       'deprecated': False,
                                                       'doc': 'Returns the index of the curve. The data type corresponding to this index is MFnData::kNurbsCurve.',
                                                       'inArgs': [],
                                                       'outArgs': [],
                                                       'returnInfo': {'doc': 'Curve index',
                                                                      'qualifiers': [],
                                                                      'type': 'uint'},
                                                       'returnType': 'uint',
                                                       'static': False,
                                                       'typeQualifiers': {},
                                                       'types': {}}],
                                       'curvePoint': [{'argInfo': {},
                                                       'args': [],
                                                       'defaults': {},
                                                       'deprecated': False,
                                                       'doc': 'Returns the curve point.',
                                                       'inArgs': [],
                                                       'outArgs': [],
                                                       'returnInfo': {'doc': 'The curve point',
                                                                      'qualifiers': [],
                                                                      'type': 'MPoint'},
                                                       'returnType': 'MPoint',
                                                       'static': False,
                                                       'typeQualifiers': {},
                                                       'types': {}}],
                                       'isDrawCurveOn': [{'argInfo': {},
                                                          'args': [],
                                                          'defaults': {},
                                                          'deprecated': False,
                                                          'doc': 'Returns 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': {},
                                                          'types': {}}],
                                       'paramIndex': [{'argInfo': {},
                                                       'args': [],
                                                       'defaults': {},
                                                       'deprecated': False,
                                                       'doc': 'Returns 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': 'uint'},
                                                       'returnType': 'uint',
                                                       'static': False,
                                                       'typeQualifiers': {},
                                                       'types': {}}],
                                       'parameter': [{'argInfo': {},
                                                      'args': [],
                                                      'defaults': {},
                                                      'deprecated': False,
                                                      'doc': 'Returns the parameter.',
                                                      'inArgs': [],
                                                      'inverse': ('setParameter',
                                                                  False),
                                                      'outArgs': [],
                                                      'returnInfo': {'doc': 'Parameter',
                                                                     'qualifiers': [],
                                                                     'type': 'double'},
                                                      'returnType': 'double',
                                                      'static': False,
                                                      'typeQualifiers': {},
                                                      'types': {}}],
                                       'setDrawCurve': [{'argInfo': {'state': {'doc': 'whether or not the curve should be drawn',
                                                                               'type': 'bool'}},
                                                         'args': [('state',
                                                                   'bool',
                                                                   'in')],
                                                         'defaults': {},
                                                         'deprecated': False,
                                                         'doc': 'Sets whether or not the curve is drawn.',
                                                         'inArgs': ['state'],
                                                         'outArgs': [],
                                                         'returnInfo': {'doc': '',
                                                                        'qualifiers': [],
                                                                        'type': None},
                                                         'returnType': None,
                                                         'static': False,
                                                         'typeQualifiers': {},
                                                         'types': {'state': 'bool'}}],
                                       'setParameter': [{'argInfo': {'parameter': {'doc': 'the parameter',
                                                                                   'type': 'double'}},
                                                         'args': [('parameter',
                                                                   'double',
                                                                   'in')],
                                                         'defaults': {},
                                                         'deprecated': False,
                                                         'doc': 'Sets the parameter.',
                                                         'inArgs': ['parameter'],
                                                         'inverse': ('parameter',
                                                                     True),
                                                         'outArgs': [],
                                                         'returnInfo': {'doc': '',
                                                                        'qualifiers': [],
                                                                        'type': None},
                                                         'returnType': None,
                                                         'static': False,
                                                         'typeQualifiers': {},
                                                         'types': {'parameter': 'double'}}],
                                       'type': [{'argInfo': {},
                                                 'args': [],
                                                 'defaults': {},
                                                 'deprecated': False,
                                                 'doc': 'Function set type',
                                                 'inArgs': [],
                                                 'outArgs': [],
                                                 'returnInfo': {'doc': 'the class type.',
                                                                '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': 'Returns the name of this class.',
                                                        'inArgs': [],
                                                        'outArgs': [],
                                                        'returnInfo': {'doc': 'Name of this class.',
                                                                       'qualifiers': ['*'],
                                                                       'type': 'char'},
                                                        'returnType': 'char',
                                                        'static': True,
                                                        'typeQualifiers': {},
                                                        'types': {}}],
                                         'connectToParamPlug': [{'argInfo': {'paramPlug': {'doc': 'the param plug',
                                                                                           'type': 'MPlug'}},
                                                                 'args': [('paramPlug',
                                                                           'MPlug',
                                                                           'in')],
                                                                 'defaults': {},
                                                                 'deprecated': False,
                                                                 'doc': 'Connect 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': 'Connect 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': "Creates 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': {},
                                                     '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': "Creates 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': {'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': 'Returns 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': 'Returns 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': {},
                                                              'types': {}}],
                                         'paramIndex': [{'argInfo': {},
                                                         'args': [],
                                                         'defaults': {},
                                                         'deprecated': False,
                                                         'doc': 'Returns 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': 'uint'},
                                                         'returnType': 'uint',
                                                         'static': False,
                                                         'typeQualifiers': {},
                                                         'types': {}}],
                                         'setDrawArrows': [{'argInfo': {'state': {'doc': 'whether or not the arrows should be drawn',
                                                                                  'type': 'bool'}},
                                                            'args': [('state',
                                                                      'bool',
                                                                      'in')],
                                                            'defaults': {},
                                                            'deprecated': False,
                                                            'doc': 'Sets whether or not the arrows should be drawn.',
                                                            'inArgs': ['state'],
                                                            'outArgs': [],
                                                            'returnInfo': {'doc': '',
                                                                           'qualifiers': [],
                                                                           'type': None},
                                                            'returnType': None,
                                                            'static': False,
                                                            'typeQualifiers': {},
                                                            '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': 'Sets whether or not the surface is drawn.',
                                                             'inArgs': ['state'],
                                                             'outArgs': [],
                                                             'returnInfo': {'doc': '',
                                                                            'qualifiers': [],
                                                                            'type': None},
                                                             'returnType': None,
                                                             'static': False,
                                                             'typeQualifiers': {},
                                                             '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': 'Sets the u and v parameters.',
                                                            'inArgs': ['u',
                                                                       'v'],
                                                            'inverse': ('getParameters',
                                                                        True),
                                                            'outArgs': [],
                                                            'returnInfo': {'doc': '',
                                                                           'qualifiers': [],
                                                                           'type': None},
                                                            'returnType': None,
                                                            'static': False,
                                                            'typeQualifiers': {},
                                                            'types': {'u': 'double',
                                                                      'v': 'double'}}],
                                         'surfaceIndex': [{'argInfo': {},
                                                           'args': [],
                                                           'defaults': {},
                                                           'deprecated': False,
                                                           'doc': 'Returns the index of the surface. The data type corresponding to this index is MFnData::kNurbsSurface.',
                                                           'inArgs': [],
                                                           'outArgs': [],
                                                           'returnInfo': {'doc': 'Surface index',
                                                                          'qualifiers': [],
                                                                          'type': 'uint'},
                                                           'returnType': 'uint',
                                                           'static': False,
                                                           'typeQualifiers': {},
                                                           'types': {}}],
                                         'type': [{'argInfo': {},
                                                   'args': [],
                                                   'defaults': {},
                                                   'deprecated': False,
                                                   'doc': 'Function set type',
                                                   'inArgs': [],
                                                   'outArgs': [],
                                                   'returnInfo': {'doc': 'the class type.',
                                                                  'qualifiers': [],
                                                                  'type': ('MFn',
                                                                           'Type')},
                                                   'returnType': ('MFn',
                                                                  'Type'),
                                                   'static': False,
                                                   'typeQualifiers': {},
                                                   'types': {}}]},
                             'pymelEnums': {}},
  'MFnRadialField': {'enums': {},
                     'invertibles': [('setType', 'radialType')],
                     'methods': {'className': [{'argInfo': {},
                                                'args': [],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': 'Returns the name of this class.',
                                                'inArgs': [],
                                                'outArgs': [],
                                                'returnInfo': {'doc': 'Name of this class.',
                                                               'qualifiers': ['*'],
                                                               'type': 'char'},
                                                'returnType': 'char',
                                                'static': True,
                                                'typeQualifiers': {},
                                                'types': {}}],
                                 'radialType': [{'argInfo': {},
                                                 'args': [],
                                                 'defaults': {},
                                                 'deprecated': False,
                                                 'doc': 'Returns 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': {},
                                                 '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': 'Sets 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': {},
                                              'types': {'value': 'double'}}],
                                 'type': [{'argInfo': {},
                                           'args': [],
                                           'defaults': {},
                                           'deprecated': False,
                                           'doc': 'Function set type',
                                           'inArgs': [],
                                           'inverse': None,
                                           'outArgs': [],
                                           'returnInfo': {'doc': 'the class type.',
                                                          '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': 'Returns the namespace associated with this reference.',
                                                        'inArgs': ['baseName'],
                                                        'outArgs': [],
                                                        'returnInfo': {'doc': 'The namespace of this reference',
                                                                       'qualifiers': [],
                                                                       'type': 'MString'},
                                                        'returnType': 'MString',
                                                        'static': False,
                                                        'typeQualifiers': {},
                                                        'types': {'baseName': 'bool'}}],
                               'className': [{'argInfo': {},
                                              'args': [],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': 'Returns the name of this class.',
                                              'inArgs': [],
                                              'outArgs': [],
                                              'returnInfo': {'doc': 'Name of this class.',
                                                             'qualifiers': ['*'],
                                                             'type': 'char'},
                                              'returnType': 'char',
                                              'static': True,
                                              'typeQualifiers': {},
                                              'types': {}}],
                               'containsNode': [{'argInfo': {'node': {'doc': 'The node to be checked',
                                                                      'type': 'MObject'}},
                                                 'args': [('node',
                                                           'MObject',
                                                           'in')],
                                                 'defaults': {},
                                                 'deprecated': False,
                                                 'doc': 'Returns 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': {'node': ['const',
                                                                             '&']},
                                                 'types': {'node': 'MObject'}}],
                               'containsNodeExactly': [{'argInfo': {'node': {'doc': 'The node to be checked',
                                                                             'type': 'MObject'}},
                                                        'args': [('node',
                                                                  'MObject',
                                                                  'in')],
                                                        'defaults': {},
                                                        'deprecated': False,
                                                        'doc': 'Returns 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': {'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': 'Returns 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': {},
                                             'types': {'includeCopyNumber': 'bool',
                                                       'includePath': 'bool',
                                                       'resolvedName': 'bool'}}],
                               'ignoreReferenceEdits': [{'argInfo': {},
                                                         'args': [],
                                                         'defaults': {},
                                                         'deprecated': False,
                                                         'doc': 'Indicates whether reference edits will be tracked and logged or not.',
                                                         'inArgs': [],
                                                         'inverse': ('setIgnoreReferenceEdits',
                                                                     False),
                                                         'outArgs': [],
                                                         'returnInfo': {'doc': 'True if reference edits are ignored, otherwise false.',
                                                                        'qualifiers': [],
                                                                        'type': 'bool'},
                                                         'returnType': 'bool',
                                                         'static': True,
                                                         'typeQualifiers': {},
                                                         'types': {}}],
                               'isExportEditsFile': [{'argInfo': {},
                                                      'args': [],
                                                      'defaults': {},
                                                      'deprecated': False,
                                                      'doc': 'Returns 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': {},
                                                      'types': {}}],
                               'isLoaded': [{'argInfo': {},
                                             'args': [],
                                             'defaults': {},
                                             'deprecated': False,
                                             'doc': 'Returns 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': {},
                                             'types': {}}],
                               'isLocked': [{'argInfo': {},
                                             'args': [],
                                             'defaults': {},
                                             'deprecated': False,
                                             'doc': 'Returns 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': {},
                                             'types': {}}],
                               'nodes': [{'argInfo': {'nodeList': {'doc': 'the nodes from this reference',
                                                                   'type': 'MObjectArray'}},
                                          'args': [('nodeList',
                                                    'MObjectArray',
                                                    'out')],
                                          'defaults': {},
                                          'deprecated': False,
                                          'doc': 'Returns an array of the nodes associated with this reference.',
                                          'inArgs': [],
                                          'outArgs': ['nodeList'],
                                          'returnInfo': {'doc': '',
                                                         'qualifiers': [],
                                                         'type': None},
                                          'returnType': None,
                                          'static': False,
                                          'typeQualifiers': {'nodeList': ['&']},
                                          'types': {'nodeList': 'MObjectArray'}}],
                               'parentAssembly': [{'argInfo': {},
                                                   'args': [],
                                                   'defaults': {},
                                                   'deprecated': False,
                                                   'doc': 'Returns 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': {},
                                                   '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': 'Returns 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': {},
                                                   'types': {'includeCopyNumber': 'bool',
                                                             'includePath': 'bool',
                                                             'resolveName': 'bool'}}],
                               'parentReference': [{'argInfo': {},
                                                    'args': [],
                                                    'defaults': {},
                                                    'deprecated': False,
                                                    'doc': 'Returns 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': {},
                                                    'types': {}}],
                               'setIgnoreReferenceEdits': [{'argInfo': {'ignoreEdits': {'doc': 'If true reference edits will not be logged.',
                                                                                        'type': 'bool'}},
                                                            'args': [('ignoreEdits',
                                                                      'bool',
                                                                      'in')],
                                                            'defaults': {},
                                                            'deprecated': False,
                                                            'doc': 'Specify 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': {},
                                                            'types': {'ignoreEdits': 'bool'}}],
                               'type': [{'argInfo': {},
                                         'args': [],
                                         'defaults': {},
                                         'deprecated': False,
                                         'doc': 'Function set type',
                                         'inArgs': [],
                                         'outArgs': [],
                                         'returnInfo': {'doc': 'the class type.',
                                                        'qualifiers': [],
                                                        'type': ('MFn',
                                                                 'Type')},
                                         'returnType': ('MFn', 'Type'),
                                         'static': False,
                                         'typeQualifiers': {},
                                         'types': {}}]},
                   'pymelEnums': {},
                   'pymelMethods': {'ignoreReferenceEdits': 'getIgnoreReferenceEdits'}},
  'MFnReflectShader': {'enums': {},
                       'invertibles': [('setReflectedColor', 'reflectedColor'),
                                       ('setReflectedRayDepthLimit',
                                        'reflectedRayDepthLimit'),
                                       ('setReflectivity', 'reflectivity'),
                                       ('setSpecularColor', 'specularColor')],
                       'methods': {'className': [{'argInfo': {},
                                                  'args': [],
                                                  'defaults': {},
                                                  'deprecated': False,
                                                  'doc': 'Returns the name of this class.',
                                                  'inArgs': [],
                                                  'outArgs': [],
                                                  'returnInfo': {'doc': 'Name of this class.',
                                                                 'qualifiers': ['*'],
                                                                 'type': 'char'},
                                                  'returnType': 'char',
                                                  'static': True,
                                                  'typeQualifiers': {},
                                                  'types': {}}],
                                   'reflectedColor': [{'argInfo': {},
                                                       'args': [],
                                                       'defaults': {},
                                                       'deprecated': False,
                                                       'doc': 'Retrieves 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': {},
                                                       'types': {}}],
                                   'reflectedRayDepthLimit': [{'argInfo': {},
                                                               'args': [],
                                                               'defaults': {},
                                                               'deprecated': False,
                                                               'doc': 'Retrieves 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': {},
                                                               'types': {}}],
                                   'reflectivity': [{'argInfo': {},
                                                     'args': [],
                                                     'defaults': {},
                                                     'deprecated': False,
                                                     'doc': 'Retrieves 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': {},
                                                     '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': 'Sets 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': 'Sets 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': 'Sets 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': 'Sets 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': 'Retrieves 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': {},
                                                      'types': {}}],
                                   'type': [{'argInfo': {},
                                             'args': [],
                                             'defaults': {},
                                             'deprecated': False,
                                             'doc': 'Function set type',
                                             'inArgs': [],
                                             'outArgs': [],
                                             'returnInfo': {'doc': 'the class type.',
                                                            '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': 'Returns 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': {'scenePlug': ['const',
                                                                                      '&']},
                                                     'types': {'scenePlug': 'MPlug'}}],
                                 'className': [{'argInfo': {},
                                                'args': [],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': 'Returns the name of this class.',
                                                'inArgs': [],
                                                'outArgs': [],
                                                'returnInfo': {'doc': 'Name of this class.',
                                                               'qualifiers': ['*'],
                                                               'type': 'char'},
                                                'returnType': 'char',
                                                'static': True,
                                                'typeQualifiers': {},
                                                'types': {}}],
                                 'currentLayer': [{'argInfo': {},
                                                   'args': [],
                                                   'defaults': {},
                                                   'deprecated': False,
                                                   'doc': 'Returns 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': {},
                                                   'types': {}}],
                                 'defaultRenderLayer': [{'argInfo': {},
                                                         'args': [],
                                                         'defaults': {},
                                                         'deprecated': False,
                                                         'doc': 'Returns 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': {},
                                                         'types': {}}],
                                 'externalRenderPasses': [{'argInfo': {'renderPassArray': {'doc': 'Array to which the result of the search is written.',
                                                                                           'type': 'MObjectArray'}},
                                                           'args': [('renderPassArray',
                                                                     'MObjectArray',
                                                                     'out')],
                                                           'defaults': {},
                                                           'deprecated': False,
                                                           'doc': 'The 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': ['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': 'This 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': {'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': 'The 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': {'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': 'Returns 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': {'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': 'The 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': {'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': [('array',
                                                              'MObjectArray',
                                                              'out'),
                                                             ('recurse',
                                                              'bool',
                                                              'in')],
                                                    'defaults': {'recurse': False},
                                                    'deprecated': False,
                                                    'doc': 'Returns the container layers for this layer. Container layers provide the ability for a given render layer to "contain" other render layers.',
                                                    'inArgs': ['recurse'],
                                                    'outArgs': ['array'],
                                                    'returnInfo': {'doc': '',
                                                                   'qualifiers': [],
                                                                   'type': None},
                                                    'returnType': None,
                                                    'static': False,
                                                    'typeQualifiers': {'array': ['&']},
                                                    'types': {'array': 'MObjectArray',
                                                              'recurse': 'bool'}}],
                                 'listAllRenderLayers': [{'argInfo': {'array': {'doc': 'MObjectArray of render layers.',
                                                                                'type': 'MObjectArray'}},
                                                          'args': [('array',
                                                                    'MObjectArray',
                                                                    'out')],
                                                          'defaults': {},
                                                          'deprecated': False,
                                                          'doc': 'Returns the list of render layers currently in the system.',
                                                          'inArgs': [],
                                                          'outArgs': ['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': [('objectsInLayer',
                                                            'MObjectArray',
                                                            'out')],
                                                  'defaults': {},
                                                  'deprecated': False,
                                                  'doc': 'Returns the objects present in the render layer.',
                                                  'inArgs': [],
                                                  'outArgs': ['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': 'Returns 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': {'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': 'Returns 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': {'objectInstance': ['const',
                                                                                          '&'],
                                                                       'renderPass': ['const',
                                                                                      '&']},
                                                    'types': {'objectInstance': 'MDagPath',
                                                              'renderPass': 'MObject'}}],
                                 'type': [{'argInfo': {},
                                           'args': [],
                                           'defaults': {},
                                           'deprecated': False,
                                           'doc': 'Function set type',
                                           'inArgs': [],
                                           'outArgs': [],
                                           'returnInfo': {'doc': 'the class type.',
                                                          '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': 'Returns the name of this class.',
                                               'inArgs': [],
                                               'outArgs': [],
                                               'returnInfo': {'doc': 'Name of this class.',
                                                              'qualifiers': ['*'],
                                                              'type': 'char'},
                                               'returnType': 'char',
                                               'static': True,
                                               'typeQualifiers': {},
                                               'types': {}}],
                                'customTokenString': [{'argInfo': {},
                                                       'args': [],
                                                       'defaults': {},
                                                       'deprecated': False,
                                                       'doc': 'Returns 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': {},
                                                       'types': {}}],
                                'frameBufferChannels': [{'argInfo': {},
                                                         'args': [],
                                                         'defaults': {},
                                                         'deprecated': False,
                                                         'doc': 'Returns the number of channels of the frame buffer associated with the render pass.',
                                                         'inArgs': [],
                                                         'outArgs': [],
                                                         'returnInfo': {'doc': '',
                                                                        'qualifiers': [],
                                                                        'type': 'uint'},
                                                         'returnType': 'uint',
                                                         'static': False,
                                                         'typeQualifiers': {},
                                                         'types': {}}],
                                'frameBufferType': [{'argInfo': {},
                                                     'args': [],
                                                     'defaults': {},
                                                     'deprecated': False,
                                                     'doc': 'Returns 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': {},
                                                     'types': {}}],
                                'getImplementation': [{'argInfo': {},
                                                       'args': [],
                                                       'defaults': {},
                                                       'deprecated': False,
                                                       'doc': 'Returns the render pass implementation that was resolved by the previous call to setImplementation.',
                                                       'inArgs': [],
                                                       'inverse': ('setImplementation',
                                                                   False),
                                                       'outArgs': [],
                                                       'returnInfo': {'doc': '',
                                                                      'qualifiers': ['*'],
                                                                      'type': 'MPxRenderPassImpl'},
                                                       'returnType': 'MPxRenderPassImpl',
                                                       'static': False,
                                                       'typeQualifiers': {},
                                                       'types': {}}],
                                'passID': [{'argInfo': {},
                                            'args': [],
                                            'defaults': {},
                                            'deprecated': False,
                                            'doc': 'Returns 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': {},
                                            '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': 'Returns 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': {'renderer': ['const',
                                                                                       '&']},
                                                       'types': {'renderer': 'MString'}}],
                                'type': [{'argInfo': {},
                                          'args': [],
                                          'defaults': {},
                                          'deprecated': False,
                                          'doc': 'Function set type',
                                          'inArgs': [],
                                          'outArgs': [],
                                          'returnInfo': {'doc': 'the class type.',
                                                         'qualifiers': [],
                                                         'type': ('MFn',
                                                                  'Type')},
                                          'returnType': ('MFn', 'Type'),
                                          'static': False,
                                          'typeQualifiers': {},
                                          'types': {}}],
                                'usesFiltering': [{'argInfo': {},
                                                   'args': [],
                                                   'defaults': {},
                                                   'deprecated': False,
                                                   'doc': 'Returns 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': {},
                                                   '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': [('setRotateMode', 'rotateMode'),
                                     ('setSnapIncrement', 'snapIncrement')],
                     'methods': {'className': [{'argInfo': {},
                                                'args': [],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': 'Returns the name of this class.',
                                                'inArgs': [],
                                                'outArgs': [],
                                                'returnInfo': {'doc': 'Name of this class.',
                                                               'qualifiers': ['*'],
                                                               'type': 'char'},
                                                'returnType': 'char',
                                                'static': True,
                                                'typeQualifiers': {},
                                                'types': {}}],
                                 'connectToRotationCenterPlug': [{'argInfo': {'rotationCenterPlug': {'doc': 'The plug to connect the rotation center to',
                                                                                                     'type': 'MPlug'}},
                                                                  'args': [('rotationCenterPlug',
                                                                            'MPlug',
                                                                            'in')],
                                                                  'defaults': {},
                                                                  'deprecated': False,
                                                                  'doc': 'Create 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': 'Create 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': 'Creates 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': {},
                                             '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': 'Creates 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': {'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': 'Configures 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': 'Returns true when snap mode is on.',
                                                   'inArgs': [],
                                                   'outArgs': [],
                                                   'returnInfo': {'doc': 'Snap mode',
                                                                  'qualifiers': [],
                                                                  'type': 'bool'},
                                                   'returnType': 'bool',
                                                   'static': False,
                                                   'typeQualifiers': {},
                                                   'types': {}}],
                                 'rotateMode': [{'argInfo': {},
                                                 'args': [],
                                                 'defaults': {},
                                                 'deprecated': False,
                                                 'doc': 'Returns the current rotation mode.',
                                                 'inArgs': [],
                                                 'inverse': ('setRotateMode',
                                                             False),
                                                 'outArgs': [],
                                                 'returnInfo': {'doc': 'The current rotation mode',
                                                                'qualifiers': [],
                                                                'type': ('MFnRotateManip',
                                                                         'RotateMode')},
                                                 'returnType': ('MFnRotateManip',
                                                                'RotateMode'),
                                                 'static': False,
                                                 'typeQualifiers': {},
                                                 'types': {}}],
                                 'rotationCenterIndex': [{'argInfo': {},
                                                          'args': [],
                                                          'defaults': {},
                                                          'deprecated': False,
                                                          'doc': 'Returns the index of the rotation center for the manipulator.',
                                                          'inArgs': [],
                                                          'outArgs': [],
                                                          'returnInfo': {'doc': 'Rotation center index',
                                                                         'qualifiers': [],
                                                                         'type': 'uint'},
                                                          'returnType': 'uint',
                                                          'static': False,
                                                          'typeQualifiers': {},
                                                          'types': {}}],
                                 'rotationIndex': [{'argInfo': {},
                                                    'args': [],
                                                    'defaults': {},
                                                    'deprecated': False,
                                                    'doc': 'Returns 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': 'uint'},
                                                    'returnType': 'uint',
                                                    'static': False,
                                                    'typeQualifiers': {},
                                                    'types': {}}],
                                 'setInitialRotation': [{'argInfo': {'rotation': {'doc': 'The initial rotation',
                                                                                  'type': 'MEulerRotation'}},
                                                         'args': [('rotation',
                                                                   'MEulerRotation',
                                                                   'in')],
                                                         'defaults': {},
                                                         'deprecated': False,
                                                         'doc': 'Sets 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': 'Sets 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': {},
                                                    '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': 'Sets 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': 'Sets 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': {},
                                                       'types': {'snapInc': 'double'}}],
                                 'setSnapMode': [{'argInfo': {'snapEnabled': {'doc': 'The new snap mode',
                                                                              'type': 'bool'}},
                                                  'args': [('snapEnabled',
                                                            'bool',
                                                            'in')],
                                                  'defaults': {},
                                                  'deprecated': False,
                                                  'doc': 'Sets 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': {},
                                                  'types': {'snapEnabled': 'bool'}}],
                                 'snapIncrement': [{'argInfo': {},
                                                    'args': [],
                                                    'defaults': {},
                                                    'deprecated': False,
                                                    'doc': 'Returns the snapping increment in degrees.',
                                                    'inArgs': [],
                                                    'inverse': ('setSnapIncrement',
                                                                False),
                                                    'outArgs': [],
                                                    'returnInfo': {'doc': 'Snapping increment (degrees)',
                                                                   'qualifiers': [],
                                                                   'type': 'double'},
                                                    'returnType': 'double',
                                                    'static': False,
                                                    'typeQualifiers': {},
                                                    'types': {}}],
                                 'type': [{'argInfo': {},
                                           'args': [],
                                           'defaults': {},
                                           'deprecated': False,
                                           'doc': 'Function set type',
                                           'inArgs': [],
                                           'outArgs': [],
                                           'returnInfo': {'doc': 'the class type.',
                                                          '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': {'ScaleOrientationMode': {'valueDocs': {},
                                                       'values': "Enum('ScaleOrientationMode', {'kDefaultOrientation': 0, 'kArbitraryOrientation': 1})"}},
                    'invertibles': [('setOrientation', 'getOrientation'),
                                    ('setOrientationMode',
                                     'getOrientationMode'),
                                    ('setSnapIncrement', 'snapIncrement')],
                    'methods': {'className': [{'argInfo': {},
                                               'args': [],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': 'Returns the name of this class.',
                                               'inArgs': [],
                                               'outArgs': [],
                                               'returnInfo': {'doc': 'Name of this class.',
                                                              'qualifiers': ['*'],
                                                              'type': 'char'},
                                               'returnType': 'char',
                                               'static': True,
                                               'typeQualifiers': {},
                                               'types': {}}],
                                'connectToScaleCenterPlug': [{'argInfo': {'scaleCenterPlug': {'doc': 'The plug to connect the scale center to',
                                                                                              'type': 'MPlug'}},
                                                              'args': [('scaleCenterPlug',
                                                                        'MPlug',
                                                                        'in')],
                                                              'defaults': {},
                                                              'deprecated': False,
                                                              'doc': 'Create 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': 'Create 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': 'Creates 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': {},
                                            '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': 'Creates 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': {'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': 'Configures 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': 'Returns 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': {},
                                                    'types': {}}],
                                'getOrientationMode': [{'argInfo': {},
                                                        'args': [],
                                                        'defaults': {},
                                                        'deprecated': False,
                                                        'doc': 'Gets 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': {},
                                                        'types': {}}],
                                'isSnapModeOn': [{'argInfo': {},
                                                  'args': [],
                                                  'defaults': {},
                                                  'deprecated': False,
                                                  'doc': 'Returns true when snap mode is on.',
                                                  'inArgs': [],
                                                  'outArgs': [],
                                                  'returnInfo': {'doc': 'Snap mode',
                                                                 'qualifiers': [],
                                                                 'type': 'bool'},
                                                  'returnType': 'bool',
                                                  'static': False,
                                                  'typeQualifiers': {},
                                                  'types': {}}],
                                'scaleCenterIndex': [{'argInfo': {},
                                                      'args': [],
                                                      'defaults': {},
                                                      'deprecated': False,
                                                      'doc': 'Returns the index of the scale center manipVal for this manipulator.',
                                                      'inArgs': [],
                                                      'outArgs': [],
                                                      'returnInfo': {'doc': 'Scale center index',
                                                                     'qualifiers': [],
                                                                     'type': 'uint'},
                                                      'returnType': 'uint',
                                                      'static': False,
                                                      'typeQualifiers': {},
                                                      'types': {}}],
                                'scaleIndex': [{'argInfo': {},
                                                'args': [],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': 'Returns the index of the scale manipVal for this manipulator.',
                                                'inArgs': [],
                                                'outArgs': [],
                                                'returnInfo': {'doc': 'Scale index',
                                                               'qualifiers': [],
                                                               'type': 'uint'},
                                                'returnType': 'uint',
                                                'static': False,
                                                'typeQualifiers': {},
                                                'types': {}}],
                                'setInitialScale': [{'argInfo': {'scale': {'doc': 'The initial scale',
                                                                           'type': 'MVector'}},
                                                     'args': [('scale',
                                                               'MVector',
                                                               'in')],
                                                     'defaults': {},
                                                     'deprecated': False,
                                                     'doc': 'Sets 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': 'Sets 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': 'Sets the orientation mode of the MFnScaleManip.',
                                                        'inArgs': ['mode'],
                                                        'inverse': ('getOrientationMode',
                                                                    True),
                                                        'outArgs': [],
                                                        'returnInfo': {'doc': '',
                                                                       'qualifiers': [],
                                                                       'type': None},
                                                        'returnType': None,
                                                        'static': False,
                                                        'typeQualifiers': {},
                                                        'types': {'mode': ('MFnScaleManip',
                                                                           'ScaleOrientationMode')}}],
                                'setSnapIncrement': [{'argInfo': {'snapInc': {'doc': 'The new snap increment',
                                                                              'type': 'double'}},
                                                      'args': [('snapInc',
                                                                'double',
                                                                'in')],
                                                      'defaults': {},
                                                      'deprecated': False,
                                                      'doc': 'Sets 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': {},
                                                      'types': {'snapInc': 'double'}}],
                                'setSnapMode': [{'argInfo': {'snapEnabled': {'doc': 'The new snap mode',
                                                                             'type': 'bool'}},
                                                 'args': [('snapEnabled',
                                                           'bool',
                                                           'in')],
                                                 'defaults': {},
                                                 'deprecated': False,
                                                 'doc': 'Sets 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': {},
                                                 'types': {'snapEnabled': 'bool'}}],
                                'snapIncrement': [{'argInfo': {},
                                                   'args': [],
                                                   'defaults': {},
                                                   'deprecated': False,
                                                   'doc': 'Returns the snapping increment in working units.',
                                                   'inArgs': [],
                                                   'inverse': ('setSnapIncrement',
                                                               False),
                                                   'outArgs': [],
                                                   'returnInfo': {'doc': 'Snapping increment',
                                                                  'qualifiers': [],
                                                                  'type': 'double'},
                                                   'returnType': 'double',
                                                   'static': False,
                                                   'typeQualifiers': {},
                                                   'types': {}}],
                                'type': [{'argInfo': {},
                                          'args': [],
                                          'defaults': {},
                                          'deprecated': False,
                                          'doc': 'Function set type',
                                          'inArgs': [],
                                          'outArgs': [],
                                          'returnInfo': {'doc': 'the class type.',
                                                         'qualifiers': [],
                                                         'type': ('MFn',
                                                                  'Type')},
                                          'returnType': ('MFn', 'Type'),
                                          'static': False,
                                          'typeQualifiers': {},
                                          'types': {}}]},
                    'pymelEnums': {'ScaleOrientationMode': "Enum('ScaleOrientationMode', [('defaultOrientation', 0), ('kDefaultOrientation', 0), ('arbitraryOrientation', 1), ('kArbitraryOrientation', 1)], multiKeys=True)"},
                    'pymelMethods': {'snapIncrement': 'getSnapIncrement'}},
  'MFnSet': {'enums': {'Restriction': {'valueDocs': {},
                                       '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': 'Add 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': 'Add 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': 'Add 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': 'Add 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': 'Returns 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': {},
                                         'types': {}}],
                         'className': [{'argInfo': {},
                                        'args': [],
                                        'defaults': {},
                                        'deprecated': False,
                                        'doc': 'Returns the name of this class.',
                                        'inArgs': [],
                                        'outArgs': [],
                                        'returnInfo': {'doc': 'Name of this class.',
                                                       'qualifiers': ['*'],
                                                       'type': 'char'},
                                        'returnType': 'char',
                                        'static': True,
                                        'typeQualifiers': {},
                                        'types': {}}],
                         'clear': [{'argInfo': {},
                                    'args': [],
                                    'defaults': {},
                                    'deprecated': False,
                                    'doc': 'Removes 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': 'Creates 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': {'members': ['const',
                                                                    '&']},
                                     'types': {'members': 'MSelectionList',
                                               'restriction': ('MFnSet',
                                                               'Restriction')}},
                                    {'argInfo': {'isLayer': {'doc': '',
                                                             'type': 'bool'},
                                                 'members': {'doc': '',
                                                             'type': 'MSelectionList'},
                                                 'restriction': {'doc': '',
                                                                 'type': ('MFnSet',
                                                                          'Restriction')}},
                                     'args': [('members',
                                               'MSelectionList',
                                               'in'),
                                              ('restriction',
                                               ('MFnSet', 'Restriction'),
                                               'in'),
                                              ('isLayer', 'bool', 'in')],
                                     'defaults': {'isLayer': False,
                                                  'restriction': ('MFnSet',
                                                                  'Restriction',
                                                                  'kNone')},
                                     'deprecated': False,
                                     'doc': '',
                                     'inArgs': ['members',
                                                'restriction',
                                                'isLayer'],
                                     'outArgs': [],
                                     'returnInfo': {'doc': '',
                                                    'qualifiers': [],
                                                    'type': 'MObject'},
                                     'returnType': 'MObject',
                                     'static': False,
                                     'typeQualifiers': {'members': ['const',
                                                                    '&']},
                                     'types': {'isLayer': 'bool',
                                               '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': 'This 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': 'This 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': 'Get 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': {'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': 'This 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': 'This 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': 'Returns 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': {},
                                              'types': {}}],
                         'intersectsWith': [{'argInfo': {'otherSet': {'doc': 'set to test for intersection with',
                                                                      'type': 'MObject'}},
                                             'args': [('otherSet',
                                                       'MObject',
                                                       'in')],
                                             'defaults': {},
                                             'deprecated': False,
                                             'doc': 'Returns 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': {'otherSet': ['const',
                                                                             '&']},
                                             'types': {'otherSet': 'MObject'}}],
                         'isMember': [{'argInfo': {'object': {'doc': 'object to test for membership',
                                                              'type': 'MObject'}},
                                       'args': [('object', 'MObject', 'in')],
                                       'defaults': {},
                                       'deprecated': False,
                                       'doc': 'Returns 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': {'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': 'Returns 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': {'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': 'Returns 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': {'plug': ['const',
                                                                   '&']},
                                       'types': {'plug': 'MPlug'}}],
                         'removeMember': [{'argInfo': {'obj': {'doc': 'the object to remove',
                                                               'type': 'MObject'}},
                                           'args': [('obj', 'MObject', 'in')],
                                           'defaults': {},
                                           'deprecated': False,
                                           'doc': 'Remove 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': 'Remove 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': 'Remove 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': 'Remove 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': 'Returns 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': {},
                                          'types': {}}],
                         'setAnnotation': [{'argInfo': {'annotation': {'doc': 'new annotation string',
                                                                       'type': 'MString'}},
                                            'args': [('annotation',
                                                      'MString',
                                                      'in')],
                                            'defaults': {},
                                            'deprecated': False,
                                            'doc': 'Sets 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'}}],
                         'setCommand': [{'argInfo': {},
                                         'args': [],
                                         'defaults': {},
                                         'deprecated': False,
                                         'doc': '',
                                         'inArgs': [],
                                         'outArgs': [],
                                         'returnInfo': {'doc': '',
                                                        'qualifiers': ['*'],
                                                        'type': ('MFnSet',
                                                                 'TsetCmd')},
                                         'returnType': ('MFnSet', 'TsetCmd'),
                                         'static': False,
                                         'typeQualifiers': {},
                                         'types': {}}],
                         'setCommandString': [{'argInfo': {},
                                               'args': [],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': '',
                                               'inArgs': [],
                                               'outArgs': [],
                                               'returnInfo': {'doc': '',
                                                              'qualifiers': [],
                                                              'type': ('MFnSet',
                                                                       'Tstring')},
                                               'returnType': ('MFnSet',
                                                              'Tstring'),
                                               'static': False,
                                               'typeQualifiers': {},
                                               'types': {}}],
                         'type': [{'argInfo': {},
                                   'args': [],
                                   'defaults': {},
                                   'deprecated': False,
                                   'doc': 'Function set type',
                                   'inArgs': [],
                                   'outArgs': [],
                                   'returnInfo': {'doc': 'the class type.',
                                                  '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': 'Add the specified element to the component.',
                                                            'inArgs': ['element'],
                                                            'outArgs': [],
                                                            'returnInfo': {'doc': '',
                                                                           'qualifiers': [],
                                                                           'type': None},
                                                            'returnType': None,
                                                            'static': False,
                                                            'typeQualifiers': {},
                                                            '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': 'Add 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': 'Returns the name of this class.',
                                                           'inArgs': [],
                                                           'outArgs': [],
                                                           'returnInfo': {'doc': 'Name of this class.',
                                                                          'qualifiers': ['*'],
                                                                          'type': 'char'},
                                                           'returnType': 'char',
                                                           'static': True,
                                                           'typeQualifiers': {},
                                                           'types': {}}],
                                            'create': [{'argInfo': {'compType': {'doc': 'the type of component to create',
                                                                                 'type': ('MFn',
                                                                                          'Type')}},
                                                        'args': [('compType',
                                                                  ('MFn',
                                                                   'Type'),
                                                                  'in')],
                                                        'defaults': {},
                                                        'deprecated': False,
                                                        'doc': 'Create 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': {},
                                                        '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': 'Returns 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': {},
                                                         'types': {'index': 'int'}}],
                                            'elementMax': [{'argInfo': {},
                                                            'args': [],
                                                            'defaults': {},
                                                            'deprecated': False,
                                                            'doc': 'Returns 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': {},
                                                            'types': {}}],
                                            'getCompleteData': [{'argInfo': {'numElements': {'doc': 'storage for the maximum number of elements',
                                                                                             'type': 'int'}},
                                                                 'args': [('numElements',
                                                                           'int',
                                                                           'out')],
                                                                 'defaults': {},
                                                                 'deprecated': False,
                                                                 'doc': 'Returns 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': 'Get 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': 'Marks 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': {},
                                                                 'types': {'numElements': 'int'}}],
                                            'type': [{'argInfo': {},
                                                      'args': [],
                                                      'defaults': {},
                                                      'deprecated': False,
                                                      'doc': 'Function set type',
                                                      'inArgs': [],
                                                      'outArgs': [],
                                                      'returnInfo': {'doc': 'the class type.',
                                                                     'qualifiers': [],
                                                                     'type': ('MFn',
                                                                              'Type')},
                                                      'returnType': ('MFn',
                                                                     'Type'),
                                                      'static': False,
                                                      'typeQualifiers': {},
                                                      'types': {}}]},
                                'pymelEnums': {}},
  'MFnSkinCluster': {'enums': {},
                     'invertibles': [('setBlendWeights', 'getBlendWeights'),
                                     ('setWeights', 'getWeights')],
                     'methods': {'className': [{'argInfo': {},
                                                'args': [],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': 'Returns the name of this class.',
                                                'inArgs': [],
                                                'outArgs': [],
                                                'returnInfo': {'doc': 'Name of this class.',
                                                               'qualifiers': ['*'],
                                                               'type': 'char'},
                                                'returnType': 'char',
                                                'static': True,
                                                'typeQualifiers': {},
                                                'types': {}}],
                                 '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': "This 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': "During 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': True,
                                                                   'doc': "This 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': 'Gets 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': 'Gets 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': 'Gets 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': True,
                                                 'doc': "This 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': True,
                                                 'doc': "This 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': 'Returns 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': 'uint'},
                                                              'returnType': 'uint',
                                                              'static': False,
                                                              'typeQualifiers': {'mpath': ['const',
                                                                                           '&']},
                                                              'types': {'mpath': 'MDagPath'}}],
                                 'influenceObjects': [{'argInfo': {'paths': {'doc': 'influence objects',
                                                                             'type': 'MDagPathArray'}},
                                                       'args': [('paths',
                                                                 'MDagPathArray',
                                                                 'out')],
                                                       'defaults': {},
                                                       'deprecated': False,
                                                       'doc': 'Returns an array of paths to the influence objects for the skinCluster.',
                                                       'inArgs': [],
                                                       'outArgs': ['paths'],
                                                       'returnInfo': {'doc': 'The number of influence objects',
                                                                      'qualifiers': [],
                                                                      'type': 'uint'},
                                                       'returnType': 'uint',
                                                       'static': False,
                                                       'typeQualifiers': {'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': [('path',
                                                                'MDagPath',
                                                                'in'),
                                                               ('components',
                                                                'MObject',
                                                                'in'),
                                                               ('weights',
                                                                'MDoubleArray',
                                                                'in')],
                                                      'defaults': {},
                                                      'deprecated': False,
                                                      'doc': "This 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': ['path',
                                                                 'components',
                                                                 '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': 'Sets 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'],
                                                                    'oldValues': ['*'],
                                                                    'path': ['const',
                                                                             '&']},
                                                 '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': 'Sets 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': ['&'],
                                                                    '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': True,
                                                 'doc': "This 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'],
                                                                    'oldValues': ['*'],
                                                                    'path': ['const',
                                                                             '&']},
                                                 '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': True,
                                                 'doc': "This 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': ['&'],
                                                                    'oldValues': ['*'],
                                                                    'path': ['const',
                                                                             '&'],
                                                                    'values': ['&']},
                                                 'types': {'components': 'MObject',
                                                           'influenceIndices': 'MIntArray',
                                                           'normalize': 'bool',
                                                           'oldValues': 'MFloatArray',
                                                           'path': 'MDagPath',
                                                           'values': 'MFloatArray'}}],
                                 'type': [{'argInfo': {},
                                           'args': [],
                                           'defaults': {},
                                           'deprecated': False,
                                           'doc': 'Function set type',
                                           'inArgs': [],
                                           'outArgs': [],
                                           'returnInfo': {'doc': 'the class type.',
                                                          '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': 'Returns the name of this class.',
                                               'inArgs': [],
                                               'outArgs': [],
                                               'returnInfo': {'doc': 'Name of this class.',
                                                              'qualifiers': ['*'],
                                                              'type': 'char'},
                                               'returnType': 'char',
                                               'static': True,
                                               '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': 'Create 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': {},
                                            'types': {'rad': 'double'}}],
                                'radius': [{'argInfo': {},
                                            'args': [],
                                            'defaults': {},
                                            'deprecated': False,
                                            'doc': 'Return 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': {},
                                            'types': {}}],
                                'setRadius': [{'argInfo': {'rad': {'doc': 'the new radius',
                                                                   'type': 'double'}},
                                               'args': [('rad',
                                                         'double',
                                                         'in')],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': 'Change 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': {},
                                               'types': {'rad': 'double'}}],
                                'type': [{'argInfo': {},
                                          'args': [],
                                          'defaults': {},
                                          'deprecated': False,
                                          'doc': 'Function set type',
                                          'inArgs': [],
                                          'outArgs': [],
                                          'returnInfo': {'doc': 'the class type.',
                                                         'qualifiers': [],
                                                         'type': ('MFn',
                                                                  'Type')},
                                          'returnType': ('MFn', 'Type'),
                                          'static': False,
                                          'typeQualifiers': {},
                                          'types': {}}]},
                    'pymelEnums': {},
                    'pymelMethods': {'radius': 'getRadius'}},
  'MFnSpotLight': {'enums': {'MBarnDoor': {'valueDocs': {},
                                           'values': "Enum('MBarnDoor', {'kLeft': 0, 'kRight': 1, 'kTop': 2, 'kBottom': 3})"},
                             'MDecayRegion': {'valueDocs': {},
                                              'values': "Enum('MDecayRegion', {'kFirst': 0, 'kSecond': 1, 'kThird': 2})"}},
                   'invertibles': [('setBarnDoorAngle', 'barnDoorAngle'),
                                   ('setBarnDoors', 'barnDoors'),
                                   ('setConeAngle', 'coneAngle'),
                                   ('setDropOff', 'dropOff'),
                                   ('setEndDistance', 'endDistance'),
                                   ('setPenumbraAngle', 'penumbraAngle'),
                                   ('setStartDistance', 'startDistance'),
                                   ('setUseDecayRegions', 'useDecayRegions')],
                   'methods': {'barnDoorAngle': [{'argInfo': {'which_door': {'doc': 'which barn door to return.',
                                                                             'type': ('MFnSpotLight',
                                                                                      'MBarnDoor')}},
                                                  'args': [('which_door',
                                                            ('MFnSpotLight',
                                                             'MBarnDoor'),
                                                            'in')],
                                                  'defaults': {},
                                                  'deprecated': False,
                                                  'doc': 'Retrieves 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': 'angular'},
                                                  'returnType': 'double',
                                                  'static': False,
                                                  'typeQualifiers': {},
                                                  'types': {'which_door': ('MFnSpotLight',
                                                                           'MBarnDoor')}}],
                               'barnDoors': [{'argInfo': {},
                                              'args': [],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': 'Retrieves 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': {},
                                              'types': {}}],
                               'className': [{'argInfo': {},
                                              'args': [],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': 'Returns the name of this class.',
                                              'inArgs': [],
                                              'outArgs': [],
                                              'returnInfo': {'doc': 'Name of this class.',
                                                             'qualifiers': ['*'],
                                                             'type': 'char'},
                                              'returnType': 'char',
                                              'static': True,
                                              'typeQualifiers': {},
                                              'types': {}}],
                               'coneAngle': [{'argInfo': {},
                                              'args': [],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': 'Retrieves 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': 'angular'},
                                              'returnType': 'double',
                                              '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': 'Creates 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': {},
                                           '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': 'Creates 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': {'parent': ['const',
                                                                         '&']},
                                           'types': {'UIvisible': 'bool',
                                                     'parent': 'MObject',
                                                     'wantTransform': 'bool'}}],
                               'dropOff': [{'argInfo': {},
                                            'args': [],
                                            'defaults': {},
                                            'deprecated': False,
                                            'doc': 'Retrieves 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': {},
                                            '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': 'Retrieves 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': {},
                                                'types': {'which_region': ('MFnSpotLight',
                                                                           'MDecayRegion')}}],
                               'penumbraAngle': [{'argInfo': {},
                                                  'args': [],
                                                  'defaults': {},
                                                  'deprecated': False,
                                                  'doc': 'Retrieves 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': 'angular'},
                                                  'returnType': 'double',
                                                  'static': False,
                                                  'typeQualifiers': {},
                                                  'types': {}}],
                               'setBarnDoorAngle': [{'argInfo': {'barn_door_angle': {'doc': 'New value for the barn door.',
                                                                                     'type': 'double',
                                                                                     'unitType': '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': 'Sets 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',
                                                                                            '&']},
                                                     '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': 'Sets 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': 'angular'}},
                                                 'args': [('cone_angle',
                                                           'double',
                                                           'in')],
                                                 'defaults': {},
                                                 'deprecated': False,
                                                 'doc': 'Sets 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': 'Sets 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': 'Sets 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',
                                                                                       '&']},
                                                   'types': {'end_distance': 'float',
                                                             'which_region': ('MFnSpotLight',
                                                                              'MDecayRegion')}}],
                               'setPenumbraAngle': [{'argInfo': {'penumbra_angle': {'doc': 'value to which the attribute will be set.',
                                                                                    'type': 'double',
                                                                                    'unitType': 'angular'}},
                                                     'args': [('penumbra_angle',
                                                               'double',
                                                               'in')],
                                                     'defaults': {},
                                                     'deprecated': False,
                                                     'doc': 'Sets 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': 'Sets 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',
                                                                                           '&']},
                                                     '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': 'Sets 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': 'Retrieves 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': {},
                                                  'types': {'which_region': ('MFnSpotLight',
                                                                             'MDecayRegion')}}],
                               'type': [{'argInfo': {},
                                         'args': [],
                                         'defaults': {},
                                         'deprecated': False,
                                         'doc': 'Function set type',
                                         'inArgs': [],
                                         'outArgs': [],
                                         'returnInfo': {'doc': 'the class type.',
                                                        'qualifiers': [],
                                                        'type': ('MFn',
                                                                 'Type')},
                                         'returnType': ('MFn', 'Type'),
                                         'static': False,
                                         'typeQualifiers': {},
                                         'types': {}}],
                               'useDecayRegions': [{'argInfo': {},
                                                    'args': [],
                                                    'defaults': {},
                                                    'deprecated': False,
                                                    'doc': 'Retrieves 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': {},
                                                    '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'}},
  'MFnStandardSurfaceShader': {'enums': {},
                               'invertibles': [('setBase', 'base'),
                                               ('setBaseColor', 'baseColor'),
                                               ('setCoat', 'coat'),
                                               ('setCoatAffectColor',
                                                'coatAffectColor'),
                                               ('setCoatAffectRoughness',
                                                'coatAffectRoughness'),
                                               ('setCoatAnisotropy',
                                                'coatAnisotropy'),
                                               ('setCoatColor', 'coatColor'),
                                               ('setCoatIOR', 'coatIOR'),
                                               ('setCoatRotation',
                                                'coatRotation'),
                                               ('setCoatRoughness',
                                                'coatRoughness'),
                                               ('setDiffuseRoughness',
                                                'diffuseRoughness'),
                                               ('setEmission', 'emission'),
                                               ('setEmissionColor',
                                                'emissionColor'),
                                               ('setMetalness', 'metalness'),
                                               ('setOpacity', 'opacity'),
                                               ('setSheen', 'sheen'),
                                               ('setSheenColor', 'sheenColor'),
                                               ('setSheenRoughness',
                                                'sheenRoughness'),
                                               ('setSpecular', 'specular'),
                                               ('setSpecularAnisotropy',
                                                'specularAnisotropy'),
                                               ('setSpecularColor',
                                                'specularColor'),
                                               ('setSpecularIOR',
                                                'specularIOR'),
                                               ('setSpecularRotation',
                                                'specularRotation'),
                                               ('setSpecularRoughness',
                                                'specularRoughness'),
                                               ('setSubsurface', 'subsurface'),
                                               ('setSubsurfaceAnisotropy',
                                                'subsurfaceAnisotropy'),
                                               ('setSubsurfaceColor',
                                                'subsurfaceColor'),
                                               ('setSubsurfaceRadius',
                                                'subsurfaceRadius'),
                                               ('setSubsurfaceScale',
                                                'subsurfaceScale'),
                                               ('setThinFilmIOR',
                                                'thinFilmIOR'),
                                               ('setThinFilmThickness',
                                                'thinFilmThickness'),
                                               ('setThinWalled', 'thinWalled'),
                                               ('setTransmission',
                                                'transmission'),
                                               ('setTransmissionColor',
                                                'transmissionColor'),
                                               ('setTransmissionDepth',
                                                'transmissionDepth'),
                                               ('setTransmissionDispersion',
                                                'transmissionDispersion'),
                                               ('setTransmissionExtraRoughness',
                                                'transmissionExtraRoughness'),
                                               ('setTransmissionScatter',
                                                'transmissionScatter'),
                                               ('setTransmissionScatterAnisotropy',
                                                'transmissionScatterAnisotropy')],
                               'methods': {'base': [{'argInfo': {},
                                                     'args': [],
                                                     'defaults': {},
                                                     'deprecated': False,
                                                     'doc': 'Retrieves the value of the "base" attribute of a standard surface shader node.',
                                                     'inArgs': [],
                                                     'inverse': ('setBase',
                                                                 False),
                                                     'outArgs': [],
                                                     'returnInfo': {'doc': 'The value of the "base" attribute of the shader node.',
                                                                    'qualifiers': [],
                                                                    'type': 'float'},
                                                     'returnType': 'float',
                                                     'static': False,
                                                     'typeQualifiers': {},
                                                     'types': {}}],
                                           'baseColor': [{'argInfo': {},
                                                          'args': [],
                                                          'defaults': {},
                                                          'deprecated': False,
                                                          'doc': 'Retrieves the value of the "baseColor" attribute of a standard surface shader node.',
                                                          'inArgs': [],
                                                          'inverse': ('setBaseColor',
                                                                      False),
                                                          'outArgs': [],
                                                          'returnInfo': {'doc': 'The value of the "baseColor" attribute of the shader node.',
                                                                         'qualifiers': [],
                                                                         'type': 'MColor'},
                                                          'returnType': 'MColor',
                                                          'static': False,
                                                          'typeQualifiers': {},
                                                          'types': {}}],
                                           'className': [{'argInfo': {},
                                                          'args': [],
                                                          'defaults': {},
                                                          'deprecated': False,
                                                          'doc': 'Returns the name of this class.',
                                                          'inArgs': [],
                                                          'outArgs': [],
                                                          'returnInfo': {'doc': 'Name of this class.',
                                                                         'qualifiers': ['*'],
                                                                         'type': 'char'},
                                                          'returnType': 'char',
                                                          'static': True,
                                                          'typeQualifiers': {},
                                                          'types': {}}],
                                           'coat': [{'argInfo': {},
                                                     'args': [],
                                                     'defaults': {},
                                                     'deprecated': False,
                                                     'doc': 'Retrieves the value of the "coat" attribute of a standard surface shader node.',
                                                     'inArgs': [],
                                                     'inverse': ('setCoat',
                                                                 False),
                                                     'outArgs': [],
                                                     'returnInfo': {'doc': 'The value of the "coat" attribute of the shader node.',
                                                                    'qualifiers': [],
                                                                    'type': 'float'},
                                                     'returnType': 'float',
                                                     'static': False,
                                                     'typeQualifiers': {},
                                                     'types': {}}],
                                           'coatAffectColor': [{'argInfo': {},
                                                                'args': [],
                                                                'defaults': {},
                                                                'deprecated': False,
                                                                'doc': 'Retrieves the value of the "coatAffectColor" attribute of a standard surface shader node.',
                                                                'inArgs': [],
                                                                'inverse': ('setCoatAffectColor',
                                                                            False),
                                                                'outArgs': [],
                                                                'returnInfo': {'doc': 'The value of the "coatAffectColor" attribute of the shader node.',
                                                                               'qualifiers': [],
                                                                               'type': 'float'},
                                                                'returnType': 'float',
                                                                'static': False,
                                                                'typeQualifiers': {},
                                                                'types': {}}],
                                           'coatAffectRoughness': [{'argInfo': {},
                                                                    'args': [],
                                                                    'defaults': {},
                                                                    'deprecated': False,
                                                                    'doc': 'Retrieves the value of the "coatAffectRoughness" attribute of a standard surface shader node.',
                                                                    'inArgs': [],
                                                                    'inverse': ('setCoatAffectRoughness',
                                                                                False),
                                                                    'outArgs': [],
                                                                    'returnInfo': {'doc': 'The value of the "coatAffectRoughness" attribute of the shader node.',
                                                                                   'qualifiers': [],
                                                                                   'type': 'float'},
                                                                    'returnType': 'float',
                                                                    'static': False,
                                                                    'typeQualifiers': {},
                                                                    'types': {}}],
                                           'coatAnisotropy': [{'argInfo': {},
                                                               'args': [],
                                                               'defaults': {},
                                                               'deprecated': False,
                                                               'doc': 'Retrieves the value of the "coatAnisotropy" attribute of a standard surface shader node.',
                                                               'inArgs': [],
                                                               'inverse': ('setCoatAnisotropy',
                                                                           False),
                                                               'outArgs': [],
                                                               'returnInfo': {'doc': 'The value of the "coatAnisotropy" attribute of the shader node.',
                                                                              'qualifiers': [],
                                                                              'type': 'float'},
                                                               'returnType': 'float',
                                                               'static': False,
                                                               'typeQualifiers': {},
                                                               'types': {}}],
                                           'coatColor': [{'argInfo': {},
                                                          'args': [],
                                                          'defaults': {},
                                                          'deprecated': False,
                                                          'doc': 'Retrieves the value of the "coatColor" attribute of a standard surface shader node.',
                                                          'inArgs': [],
                                                          'inverse': ('setCoatColor',
                                                                      False),
                                                          'outArgs': [],
                                                          'returnInfo': {'doc': 'The value of the "coatColor" attribute of the shader node.',
                                                                         'qualifiers': [],
                                                                         'type': 'MColor'},
                                                          'returnType': 'MColor',
                                                          'static': False,
                                                          'typeQualifiers': {},
                                                          'types': {}}],
                                           'coatIOR': [{'argInfo': {},
                                                        'args': [],
                                                        'defaults': {},
                                                        'deprecated': False,
                                                        'doc': 'Retrieves the value of the "coatIOR" attribute of a standard surface shader node.',
                                                        'inArgs': [],
                                                        'inverse': ('setCoatIOR',
                                                                    False),
                                                        'outArgs': [],
                                                        'returnInfo': {'doc': 'The value of the "coatIOR" attribute of the shader node.',
                                                                       'qualifiers': [],
                                                                       'type': 'float'},
                                                        'returnType': 'float',
                                                        'static': False,
                                                        'typeQualifiers': {},
                                                        'types': {}}],
                                           'coatRotation': [{'argInfo': {},
                                                             'args': [],
                                                             'defaults': {},
                                                             'deprecated': False,
                                                             'doc': 'Retrieves the value of the "coatRotation" attribute of a standard surface shader node.',
                                                             'inArgs': [],
                                                             'inverse': ('setCoatRotation',
                                                                         False),
                                                             'outArgs': [],
                                                             'returnInfo': {'doc': 'The value of the "coatRotation" attribute of the shader node.',
                                                                            'qualifiers': [],
                                                                            'type': 'float'},
                                                             'returnType': 'float',
                                                             'static': False,
                                                             'typeQualifiers': {},
                                                             'types': {}}],
                                           'coatRoughness': [{'argInfo': {},
                                                              'args': [],
                                                              'defaults': {},
                                                              'deprecated': False,
                                                              'doc': 'Retrieves the value of the "coatRoughness" attribute of a standard surface shader node.',
                                                              'inArgs': [],
                                                              'inverse': ('setCoatRoughness',
                                                                          False),
                                                              'outArgs': [],
                                                              'returnInfo': {'doc': 'The value of the "coatRoughness" attribute of the shader node.',
                                                                             'qualifiers': [],
                                                                             'type': 'float'},
                                                              'returnType': 'float',
                                                              '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': 'Creates a new standard surface 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': {},
                                                       'types': {'UIvisible': 'bool'}}],
                                           'diffuseRoughness': [{'argInfo': {},
                                                                 'args': [],
                                                                 'defaults': {},
                                                                 'deprecated': False,
                                                                 'doc': 'Retrieves the value of the "diffuseRoughness" attribute of a standard surface shader node.',
                                                                 'inArgs': [],
                                                                 'inverse': ('setDiffuseRoughness',
                                                                             False),
                                                                 'outArgs': [],
                                                                 'returnInfo': {'doc': 'The value of the "diffuseRoughness" attribute of the shader node.',
                                                                                'qualifiers': [],
                                                                                'type': 'float'},
                                                                 'returnType': 'float',
                                                                 'static': False,
                                                                 'typeQualifiers': {},
                                                                 'types': {}}],
                                           'emission': [{'argInfo': {},
                                                         'args': [],
                                                         'defaults': {},
                                                         'deprecated': False,
                                                         'doc': 'Retrieves the value of the "emission" attribute of a standard surface shader node.',
                                                         'inArgs': [],
                                                         'inverse': ('setEmission',
                                                                     False),
                                                         'outArgs': [],
                                                         'returnInfo': {'doc': 'The value of the "emission" attribute of the shader node.',
                                                                        'qualifiers': [],
                                                                        'type': 'float'},
                                                         'returnType': 'float',
                                                         'static': False,
                                                         'typeQualifiers': {},
                                                         'types': {}}],
                                           'emissionColor': [{'argInfo': {},
                                                              'args': [],
                                                              'defaults': {},
                                                              'deprecated': False,
                                                              'doc': 'Retrieves the value of the "emissionColor" attribute of a standard surface shader node.',
                                                              'inArgs': [],
                                                              'inverse': ('setEmissionColor',
                                                                          False),
                                                              'outArgs': [],
                                                              'returnInfo': {'doc': 'The value of the "emissionColor" attribute of the shader node.',
                                                                             'qualifiers': [],
                                                                             'type': 'MColor'},
                                                              'returnType': 'MColor',
                                                              'static': False,
                                                              'typeQualifiers': {},
                                                              'types': {}}],
                                           'metalness': [{'argInfo': {},
                                                          'args': [],
                                                          'defaults': {},
                                                          'deprecated': False,
                                                          'doc': 'Retrieves the value of the "metalness" attribute of a standard surface shader node.',
                                                          'inArgs': [],
                                                          'inverse': ('setMetalness',
                                                                      False),
                                                          'outArgs': [],
                                                          'returnInfo': {'doc': 'The value of the "metalness" attribute of the shader node.',
                                                                         'qualifiers': [],
                                                                         'type': 'float'},
                                                          'returnType': 'float',
                                                          'static': False,
                                                          'typeQualifiers': {},
                                                          'types': {}}],
                                           'opacity': [{'argInfo': {},
                                                        'args': [],
                                                        'defaults': {},
                                                        'deprecated': False,
                                                        'doc': 'Retrieves the value of the "opacity" attribute of a standard surface shader node.',
                                                        'inArgs': [],
                                                        'inverse': ('setOpacity',
                                                                    False),
                                                        'outArgs': [],
                                                        'returnInfo': {'doc': 'The value of the "opacity" attribute of the shader node.',
                                                                       'qualifiers': [],
                                                                       'type': 'MColor'},
                                                        'returnType': 'MColor',
                                                        'static': False,
                                                        'typeQualifiers': {},
                                                        'types': {}}],
                                           'setBase': [{'argInfo': {'base': {'doc': 'value to which the attribute will be set.',
                                                                             'type': 'float'}},
                                                        'args': [('base',
                                                                  'float',
                                                                  'in')],
                                                        'defaults': {},
                                                        'deprecated': False,
                                                        'doc': 'Sets the value of the "base" attribute of a shader node.',
                                                        'inArgs': ['base'],
                                                        'inverse': ('base',
                                                                    True),
                                                        'outArgs': [],
                                                        'returnInfo': {'doc': '',
                                                                       'qualifiers': [],
                                                                       'type': None},
                                                        'returnType': None,
                                                        'static': False,
                                                        'typeQualifiers': {'base': ['const',
                                                                                    '&']},
                                                        'types': {'base': 'float'}}],
                                           'setBaseColor': [{'argInfo': {'base_color': {'doc': 'value to which the attribute will be set.',
                                                                                        'type': 'MColor'}},
                                                             'args': [('base_color',
                                                                       'MColor',
                                                                       'in')],
                                                             'defaults': {},
                                                             'deprecated': False,
                                                             'doc': 'Sets the value of the "baseColor" attribute of a shader node.',
                                                             'inArgs': ['base_color'],
                                                             'inverse': ('baseColor',
                                                                         True),
                                                             'outArgs': [],
                                                             'returnInfo': {'doc': '',
                                                                            'qualifiers': [],
                                                                            'type': None},
                                                             'returnType': None,
                                                             'static': False,
                                                             'typeQualifiers': {'base_color': ['const',
                                                                                               '&']},
                                                             'types': {'base_color': 'MColor'}}],
                                           'setCoat': [{'argInfo': {'coat': {'doc': 'value to which the attribute will be set.',
                                                                             'type': 'float'}},
                                                        'args': [('coat',
                                                                  'float',
                                                                  'in')],
                                                        'defaults': {},
                                                        'deprecated': False,
                                                        'doc': 'Sets the value of the "coat" attribute of a shader node.',
                                                        'inArgs': ['coat'],
                                                        'inverse': ('coat',
                                                                    True),
                                                        'outArgs': [],
                                                        'returnInfo': {'doc': '',
                                                                       'qualifiers': [],
                                                                       'type': None},
                                                        'returnType': None,
                                                        'static': False,
                                                        'typeQualifiers': {'coat': ['const',
                                                                                    '&']},
                                                        'types': {'coat': 'float'}}],
                                           'setCoatAffectColor': [{'argInfo': {'coat_affect_color': {'doc': 'value to which the attribute will be set.',
                                                                                                     'type': 'float'}},
                                                                   'args': [('coat_affect_color',
                                                                             'float',
                                                                             'in')],
                                                                   'defaults': {},
                                                                   'deprecated': False,
                                                                   'doc': 'Sets the value of the "coatAffectColor" attribute of a shader node.',
                                                                   'inArgs': ['coat_affect_color'],
                                                                   'inverse': ('coatAffectColor',
                                                                               True),
                                                                   'outArgs': [],
                                                                   'returnInfo': {'doc': '',
                                                                                  'qualifiers': [],
                                                                                  'type': None},
                                                                   'returnType': None,
                                                                   'static': False,
                                                                   'typeQualifiers': {'coat_affect_color': ['const',
                                                                                                            '&']},
                                                                   'types': {'coat_affect_color': 'float'}}],
                                           'setCoatAffectRoughness': [{'argInfo': {'coat_affect_roughness': {'doc': 'value to which the attribute will be set.',
                                                                                                             'type': 'float'}},
                                                                       'args': [('coat_affect_roughness',
                                                                                 'float',
                                                                                 'in')],
                                                                       'defaults': {},
                                                                       'deprecated': False,
                                                                       'doc': 'Sets the value of the "coatAffectRoughness" attribute of a shader node.',
                                                                       'inArgs': ['coat_affect_roughness'],
                                                                       'inverse': ('coatAffectRoughness',
                                                                                   True),
                                                                       'outArgs': [],
                                                                       'returnInfo': {'doc': '',
                                                                                      'qualifiers': [],
                                                                                      'type': None},
                                                                       'returnType': None,
                                                                       'static': False,
                                                                       'typeQualifiers': {'coat_affect_roughness': ['const',
                                                                                                                    '&']},
                                                                       'types': {'coat_affect_roughness': 'float'}}],
                                           'setCoatAnisotropy': [{'argInfo': {'coat_anisotropy': {'doc': 'value to which the attribute will be set.',
                                                                                                  'type': 'float'}},
                                                                  'args': [('coat_anisotropy',
                                                                            'float',
                                                                            'in')],
                                                                  'defaults': {},
                                                                  'deprecated': False,
                                                                  'doc': 'Sets the value of the "coatAnisotropy" attribute of a shader node.',
                                                                  'inArgs': ['coat_anisotropy'],
                                                                  'inverse': ('coatAnisotropy',
                                                                              True),
                                                                  'outArgs': [],
                                                                  'returnInfo': {'doc': '',
                                                                                 'qualifiers': [],
                                                                                 'type': None},
                                                                  'returnType': None,
                                                                  'static': False,
                                                                  'typeQualifiers': {'coat_anisotropy': ['const',
                                                                                                         '&']},
                                                                  'types': {'coat_anisotropy': 'float'}}],
                                           'setCoatColor': [{'argInfo': {'coat_color': {'doc': 'value to which the attribute will be set.',
                                                                                        'type': 'MColor'}},
                                                             'args': [('coat_color',
                                                                       'MColor',
                                                                       'in')],
                                                             'defaults': {},
                                                             'deprecated': False,
                                                             'doc': 'Sets the value of the "coatColor" attribute of a shader node.',
                                                             'inArgs': ['coat_color'],
                                                             'inverse': ('coatColor',
                                                                         True),
                                                             'outArgs': [],
                                                             'returnInfo': {'doc': '',
                                                                            'qualifiers': [],
                                                                            'type': None},
                                                             'returnType': None,
                                                             'static': False,
                                                             'typeQualifiers': {'coat_color': ['const',
                                                                                               '&']},
                                                             'types': {'coat_color': 'MColor'}}],
                                           'setCoatIOR': [{'argInfo': {'coat_i_o_r': {'doc': 'value to which the attribute will be set.',
                                                                                      'type': 'float'}},
                                                           'args': [('coat_i_o_r',
                                                                     'float',
                                                                     'in')],
                                                           'defaults': {},
                                                           'deprecated': False,
                                                           'doc': 'Sets the value of the "coatIOR" attribute of a shader node.',
                                                           'inArgs': ['coat_i_o_r'],
                                                           'inverse': ('coatIOR',
                                                                       True),
                                                           'outArgs': [],
                                                           'returnInfo': {'doc': '',
                                                                          'qualifiers': [],
                                                                          'type': None},
                                                           'returnType': None,
                                                           'static': False,
                                                           'typeQualifiers': {'coat_i_o_r': ['const',
                                                                                             '&']},
                                                           'types': {'coat_i_o_r': 'float'}}],
                                           'setCoatRotation': [{'argInfo': {'coat_rotation': {'doc': 'value to which the attribute will be set.',
                                                                                              'type': 'float'}},
                                                                'args': [('coat_rotation',
                                                                          'float',
                                                                          'in')],
                                                                'defaults': {},
                                                                'deprecated': False,
                                                                'doc': 'Sets the value of the "coatRotation" attribute of a shader node.',
                                                                'inArgs': ['coat_rotation'],
                                                                'inverse': ('coatRotation',
                                                                            True),
                                                                'outArgs': [],
                                                                'returnInfo': {'doc': '',
                                                                               'qualifiers': [],
                                                                               'type': None},
                                                                'returnType': None,
                                                                'static': False,
                                                                'typeQualifiers': {'coat_rotation': ['const',
                                                                                                     '&']},
                                                                'types': {'coat_rotation': 'float'}}],
                                           'setCoatRoughness': [{'argInfo': {'coat_roughness': {'doc': 'value to which the attribute will be set.',
                                                                                                'type': 'float'}},
                                                                 'args': [('coat_roughness',
                                                                           'float',
                                                                           'in')],
                                                                 'defaults': {},
                                                                 'deprecated': False,
                                                                 'doc': 'Sets the value of the "coatRoughness" attribute of a shader node.',
                                                                 'inArgs': ['coat_roughness'],
                                                                 'inverse': ('coatRoughness',
                                                                             True),
                                                                 'outArgs': [],
                                                                 'returnInfo': {'doc': '',
                                                                                'qualifiers': [],
                                                                                'type': None},
                                                                 'returnType': None,
                                                                 'static': False,
                                                                 'typeQualifiers': {'coat_roughness': ['const',
                                                                                                       '&']},
                                                                 'types': {'coat_roughness': 'float'}}],
                                           'setDiffuseRoughness': [{'argInfo': {'diffuse_roughness': {'doc': 'value to which the attribute will be set.',
                                                                                                      'type': 'float'}},
                                                                    'args': [('diffuse_roughness',
                                                                              'float',
                                                                              'in')],
                                                                    'defaults': {},
                                                                    'deprecated': False,
                                                                    'doc': 'Sets the value of the "diffuseRoughness" attribute of a shader node.',
                                                                    'inArgs': ['diffuse_roughness'],
                                                                    'inverse': ('diffuseRoughness',
                                                                                True),
                                                                    'outArgs': [],
                                                                    'returnInfo': {'doc': '',
                                                                                   'qualifiers': [],
                                                                                   'type': None},
                                                                    'returnType': None,
                                                                    'static': False,
                                                                    'typeQualifiers': {'diffuse_roughness': ['const',
                                                                                                             '&']},
                                                                    'types': {'diffuse_roughness': 'float'}}],
                                           'setEmission': [{'argInfo': {'emission': {'doc': 'value to which the attribute will be set.',
                                                                                     'type': 'float'}},
                                                            'args': [('emission',
                                                                      'float',
                                                                      'in')],
                                                            'defaults': {},
                                                            'deprecated': False,
                                                            'doc': 'Sets the value of the "emission" attribute of a shader node.',
                                                            'inArgs': ['emission'],
                                                            'inverse': ('emission',
                                                                        True),
                                                            'outArgs': [],
                                                            'returnInfo': {'doc': '',
                                                                           'qualifiers': [],
                                                                           'type': None},
                                                            'returnType': None,
                                                            'static': False,
                                                            'typeQualifiers': {'emission': ['const',
                                                                                            '&']},
                                                            'types': {'emission': 'float'}}],
                                           'setEmissionColor': [{'argInfo': {'emission_color': {'doc': 'value to which the attribute will be set.',
                                                                                                'type': 'MColor'}},
                                                                 'args': [('emission_color',
                                                                           'MColor',
                                                                           'in')],
                                                                 'defaults': {},
                                                                 'deprecated': False,
                                                                 'doc': 'Sets the value of the "emissionColor" attribute of a shader node.',
                                                                 'inArgs': ['emission_color'],
                                                                 'inverse': ('emissionColor',
                                                                             True),
                                                                 'outArgs': [],
                                                                 'returnInfo': {'doc': '',
                                                                                'qualifiers': [],
                                                                                'type': None},
                                                                 'returnType': None,
                                                                 'static': False,
                                                                 'typeQualifiers': {'emission_color': ['const',
                                                                                                       '&']},
                                                                 'types': {'emission_color': 'MColor'}}],
                                           'setMetalness': [{'argInfo': {'metalness': {'doc': 'value to which the attribute will be set.',
                                                                                       'type': 'float'}},
                                                             'args': [('metalness',
                                                                       'float',
                                                                       'in')],
                                                             'defaults': {},
                                                             'deprecated': False,
                                                             'doc': 'Sets the value of the "metalness" attribute of a shader node.',
                                                             'inArgs': ['metalness'],
                                                             'inverse': ('metalness',
                                                                         True),
                                                             'outArgs': [],
                                                             'returnInfo': {'doc': '',
                                                                            'qualifiers': [],
                                                                            'type': None},
                                                             'returnType': None,
                                                             'static': False,
                                                             'typeQualifiers': {'metalness': ['const',
                                                                                              '&']},
                                                             'types': {'metalness': 'float'}}],
                                           'setOpacity': [{'argInfo': {'opacity': {'doc': 'value to which the attribute will be set.',
                                                                                   'type': 'MColor'}},
                                                           'args': [('opacity',
                                                                     'MColor',
                                                                     'in')],
                                                           'defaults': {},
                                                           'deprecated': False,
                                                           'doc': 'Sets the value of the "opacity" attribute of a shader node.',
                                                           'inArgs': ['opacity'],
                                                           'inverse': ('opacity',
                                                                       True),
                                                           'outArgs': [],
                                                           'returnInfo': {'doc': '',
                                                                          'qualifiers': [],
                                                                          'type': None},
                                                           'returnType': None,
                                                           'static': False,
                                                           'typeQualifiers': {'opacity': ['const',
                                                                                          '&']},
                                                           'types': {'opacity': 'MColor'}}],
                                           'setSheen': [{'argInfo': {'sheen': {'doc': 'value to which the attribute will be set.',
                                                                               'type': 'float'}},
                                                         'args': [('sheen',
                                                                   'float',
                                                                   'in')],
                                                         'defaults': {},
                                                         'deprecated': False,
                                                         'doc': 'Sets the value of the "sheen" attribute of a shader node.',
                                                         'inArgs': ['sheen'],
                                                         'inverse': ('sheen',
                                                                     True),
                                                         'outArgs': [],
                                                         'returnInfo': {'doc': '',
                                                                        'qualifiers': [],
                                                                        'type': None},
                                                         'returnType': None,
                                                         'static': False,
                                                         'typeQualifiers': {'sheen': ['const',
                                                                                      '&']},
                                                         'types': {'sheen': 'float'}}],
                                           'setSheenColor': [{'argInfo': {'sheen_color': {'doc': 'value to which the attribute will be set.',
                                                                                          'type': 'MColor'}},
                                                              'args': [('sheen_color',
                                                                        'MColor',
                                                                        'in')],
                                                              'defaults': {},
                                                              'deprecated': False,
                                                              'doc': 'Sets the value of the "sheenColor" attribute of a shader node.',
                                                              'inArgs': ['sheen_color'],
                                                              'inverse': ('sheenColor',
                                                                          True),
                                                              'outArgs': [],
                                                              'returnInfo': {'doc': '',
                                                                             'qualifiers': [],
                                                                             'type': None},
                                                              'returnType': None,
                                                              'static': False,
                                                              'typeQualifiers': {'sheen_color': ['const',
                                                                                                 '&']},
                                                              'types': {'sheen_color': 'MColor'}}],
                                           'setSheenRoughness': [{'argInfo': {'sheen_roughness': {'doc': 'value to which the attribute will be set.',
                                                                                                  'type': 'float'}},
                                                                  'args': [('sheen_roughness',
                                                                            'float',
                                                                            'in')],
                                                                  'defaults': {},
                                                                  'deprecated': False,
                                                                  'doc': 'Sets the value of the "sheenRoughness" attribute of a shader node.',
                                                                  'inArgs': ['sheen_roughness'],
                                                                  'inverse': ('sheenRoughness',
                                                                              True),
                                                                  'outArgs': [],
                                                                  'returnInfo': {'doc': '',
                                                                                 'qualifiers': [],
                                                                                 'type': None},
                                                                  'returnType': None,
                                                                  'static': False,
                                                                  'typeQualifiers': {'sheen_roughness': ['const',
                                                                                                         '&']},
                                                                  'types': {'sheen_roughness': 'float'}}],
                                           'setSpecular': [{'argInfo': {'specular': {'doc': 'value to which the attribute will be set.',
                                                                                     'type': 'float'}},
                                                            'args': [('specular',
                                                                      'float',
                                                                      'in')],
                                                            'defaults': {},
                                                            'deprecated': False,
                                                            'doc': 'Sets the value of the "specular" attribute of a shader node.',
                                                            'inArgs': ['specular'],
                                                            'inverse': ('specular',
                                                                        True),
                                                            'outArgs': [],
                                                            'returnInfo': {'doc': '',
                                                                           'qualifiers': [],
                                                                           'type': None},
                                                            'returnType': None,
                                                            'static': False,
                                                            'typeQualifiers': {'specular': ['const',
                                                                                            '&']},
                                                            'types': {'specular': 'float'}}],
                                           'setSpecularAnisotropy': [{'argInfo': {'specular_anisotropy': {'doc': 'value to which the attribute will be set.',
                                                                                                          'type': 'float'}},
                                                                      'args': [('specular_anisotropy',
                                                                                'float',
                                                                                'in')],
                                                                      'defaults': {},
                                                                      'deprecated': False,
                                                                      'doc': 'Sets the value of the "specularAnisotropy" attribute of a shader node.',
                                                                      'inArgs': ['specular_anisotropy'],
                                                                      'inverse': ('specularAnisotropy',
                                                                                  True),
                                                                      'outArgs': [],
                                                                      'returnInfo': {'doc': '',
                                                                                     'qualifiers': [],
                                                                                     'type': None},
                                                                      'returnType': None,
                                                                      'static': False,
                                                                      'typeQualifiers': {'specular_anisotropy': ['const',
                                                                                                                 '&']},
                                                                      'types': {'specular_anisotropy': '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': 'Sets 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'}}],
                                           'setSpecularIOR': [{'argInfo': {'specular_i_o_r': {'doc': 'value to which the attribute will be set.',
                                                                                              'type': 'float'}},
                                                               'args': [('specular_i_o_r',
                                                                         'float',
                                                                         'in')],
                                                               'defaults': {},
                                                               'deprecated': False,
                                                               'doc': 'Sets the value of the "specularIOR" attribute of a shader node.',
                                                               'inArgs': ['specular_i_o_r'],
                                                               'inverse': ('specularIOR',
                                                                           True),
                                                               'outArgs': [],
                                                               'returnInfo': {'doc': '',
                                                                              'qualifiers': [],
                                                                              'type': None},
                                                               'returnType': None,
                                                               'static': False,
                                                               'typeQualifiers': {'specular_i_o_r': ['const',
                                                                                                     '&']},
                                                               'types': {'specular_i_o_r': 'float'}}],
                                           'setSpecularRotation': [{'argInfo': {'specular_rotation': {'doc': 'value to which the attribute will be set.',
                                                                                                      'type': 'float'}},
                                                                    'args': [('specular_rotation',
                                                                              'float',
                                                                              'in')],
                                                                    'defaults': {},
                                                                    'deprecated': False,
                                                                    'doc': 'Sets the value of the "specularRotation" attribute of a shader node.',
                                                                    'inArgs': ['specular_rotation'],
                                                                    'inverse': ('specularRotation',
                                                                                True),
                                                                    'outArgs': [],
                                                                    'returnInfo': {'doc': '',
                                                                                   'qualifiers': [],
                                                                                   'type': None},
                                                                    'returnType': None,
                                                                    'static': False,
                                                                    'typeQualifiers': {'specular_rotation': ['const',
                                                                                                             '&']},
                                                                    'types': {'specular_rotation': 'float'}}],
                                           'setSpecularRoughness': [{'argInfo': {'specular_roughness': {'doc': 'value to which the attribute will be set.',
                                                                                                        'type': 'float'}},
                                                                     'args': [('specular_roughness',
                                                                               'float',
                                                                               'in')],
                                                                     'defaults': {},
                                                                     'deprecated': False,
                                                                     'doc': 'Sets the value of the "specularRoughness" attribute of a shader node.',
                                                                     'inArgs': ['specular_roughness'],
                                                                     'inverse': ('specularRoughness',
                                                                                 True),
                                                                     'outArgs': [],
                                                                     'returnInfo': {'doc': '',
                                                                                    'qualifiers': [],
                                                                                    'type': None},
                                                                     'returnType': None,
                                                                     'static': False,
                                                                     'typeQualifiers': {'specular_roughness': ['const',
                                                                                                               '&']},
                                                                     'types': {'specular_roughness': 'float'}}],
                                           'setSubsurface': [{'argInfo': {'subsurface': {'doc': 'value to which the attribute will be set.',
                                                                                         'type': 'float'}},
                                                              'args': [('subsurface',
                                                                        'float',
                                                                        'in')],
                                                              'defaults': {},
                                                              'deprecated': False,
                                                              'doc': 'Sets the value of the "subsurface" attribute of a shader node.',
                                                              'inArgs': ['subsurface'],
                                                              'inverse': ('subsurface',
                                                                          True),
                                                              'outArgs': [],
                                                              'returnInfo': {'doc': '',
                                                                             'qualifiers': [],
                                                                             'type': None},
                                                              'returnType': None,
                                                              'static': False,
                                                              'typeQualifiers': {'subsurface': ['const',
                                                                                                '&']},
                                                              'types': {'subsurface': 'float'}}],
                                           'setSubsurfaceAnisotropy': [{'argInfo': {'subsurface_anisotropy': {'doc': 'value to which the attribute will be set.',
                                                                                                              'type': 'float'}},
                                                                        'args': [('subsurface_anisotropy',
                                                                                  'float',
                                                                                  'in')],
                                                                        'defaults': {},
                                                                        'deprecated': False,
                                                                        'doc': 'Sets the value of the "subsurfaceAnisotropy" attribute of a shader node.',
                                                                        'inArgs': ['subsurface_anisotropy'],
                                                                        'inverse': ('subsurfaceAnisotropy',
                                                                                    True),
                                                                        'outArgs': [],
                                                                        'returnInfo': {'doc': '',
                                                                                       'qualifiers': [],
                                                                                       'type': None},
                                                                        'returnType': None,
                                                                        'static': False,
                                                                        'typeQualifiers': {'subsurface_anisotropy': ['const',
                                                                                                                     '&']},
                                                                        'types': {'subsurface_anisotropy': 'float'}}],
                                           'setSubsurfaceColor': [{'argInfo': {'subsurface_color': {'doc': 'value to which the attribute will be set.',
                                                                                                    'type': 'MColor'}},
                                                                   'args': [('subsurface_color',
                                                                             'MColor',
                                                                             'in')],
                                                                   'defaults': {},
                                                                   'deprecated': False,
                                                                   'doc': 'Sets the value of the "subsurfaceColor" attribute of a shader node.',
                                                                   'inArgs': ['subsurface_color'],
                                                                   'inverse': ('subsurfaceColor',
                                                                               True),
                                                                   'outArgs': [],
                                                                   'returnInfo': {'doc': '',
                                                                                  'qualifiers': [],
                                                                                  'type': None},
                                                                   'returnType': None,
                                                                   'static': False,
                                                                   'typeQualifiers': {'subsurface_color': ['const',
                                                                                                           '&']},
                                                                   'types': {'subsurface_color': 'MColor'}}],
                                           'setSubsurfaceRadius': [{'argInfo': {'subsurface_radius': {'doc': 'value to which the attribute will be set.',
                                                                                                      'type': 'MColor'}},
                                                                    'args': [('subsurface_radius',
                                                                              'MColor',
                                                                              'in')],
                                                                    'defaults': {},
                                                                    'deprecated': False,
                                                                    'doc': 'Sets the value of the "subsurfaceRadius" attribute of a shader node.',
                                                                    'inArgs': ['subsurface_radius'],
                                                                    'inverse': ('subsurfaceRadius',
                                                                                True),
                                                                    'outArgs': [],
                                                                    'returnInfo': {'doc': '',
                                                                                   'qualifiers': [],
                                                                                   'type': None},
                                                                    'returnType': None,
                                                                    'static': False,
                                                                    'typeQualifiers': {'subsurface_radius': ['const',
                                                                                                             '&']},
                                                                    'types': {'subsurface_radius': 'MColor'}}],
                                           'setSubsurfaceScale': [{'argInfo': {'subsurface_scale': {'doc': 'value to which the attribute will be set.',
                                                                                                    'type': 'float'}},
                                                                   'args': [('subsurface_scale',
                                                                             'float',
                                                                             'in')],
                                                                   'defaults': {},
                                                                   'deprecated': False,
                                                                   'doc': 'Sets the value of the "subsurfaceScale" attribute of a shader node.',
                                                                   'inArgs': ['subsurface_scale'],
                                                                   'inverse': ('subsurfaceScale',
                                                                               True),
                                                                   'outArgs': [],
                                                                   'returnInfo': {'doc': '',
                                                                                  'qualifiers': [],
                                                                                  'type': None},
                                                                   'returnType': None,
                                                                   'static': False,
                                                                   'typeQualifiers': {'subsurface_scale': ['const',
                                                                                                           '&']},
                                                                   'types': {'subsurface_scale': 'float'}}],
                                           'setThinFilmIOR': [{'argInfo': {'thin_film_i_o_r': {'doc': 'value to which the attribute will be set.',
                                                                                               'type': 'float'}},
                                                               'args': [('thin_film_i_o_r',
                                                                         'float',
                                                                         'in')],
                                                               'defaults': {},
                                                               'deprecated': False,
                                                               'doc': 'Sets the value of the "thinFilmIOR" attribute of a shader node.',
                                                               'inArgs': ['thin_film_i_o_r'],
                                                               'inverse': ('thinFilmIOR',
                                                                           True),
                                                               'outArgs': [],
                                                               'returnInfo': {'doc': '',
                                                                              'qualifiers': [],
                                                                              'type': None},
                                                               'returnType': None,
                                                               'static': False,
                                                               'typeQualifiers': {'thin_film_i_o_r': ['const',
                                                                                                      '&']},
                                                               'types': {'thin_film_i_o_r': 'float'}}],
                                           'setThinFilmThickness': [{'argInfo': {'thin_film_thickness': {'doc': 'value to which the attribute will be set.',
                                                                                                         'type': 'float'}},
                                                                     'args': [('thin_film_thickness',
                                                                               'float',
                                                                               'in')],
                                                                     'defaults': {},
                                                                     'deprecated': False,
                                                                     'doc': 'Sets the value of the "thinFilmThickness" attribute of a shader node.',
                                                                     'inArgs': ['thin_film_thickness'],
                                                                     'inverse': ('thinFilmThickness',
                                                                                 True),
                                                                     'outArgs': [],
                                                                     'returnInfo': {'doc': '',
                                                                                    'qualifiers': [],
                                                                                    'type': None},
                                                                     'returnType': None,
                                                                     'static': False,
                                                                     'typeQualifiers': {'thin_film_thickness': ['const',
                                                                                                                '&']},
                                                                     'types': {'thin_film_thickness': 'float'}}],
                                           'setThinWalled': [{'argInfo': {'thin_walled': {'doc': 'value to which the attribute will be set.',
                                                                                          'type': 'bool'}},
                                                              'args': [('thin_walled',
                                                                        'bool',
                                                                        'in')],
                                                              'defaults': {},
                                                              'deprecated': False,
                                                              'doc': 'Sets the value of the "thinWalled" attribute of a shader node.',
                                                              'inArgs': ['thin_walled'],
                                                              'inverse': ('thinWalled',
                                                                          True),
                                                              'outArgs': [],
                                                              'returnInfo': {'doc': '',
                                                                             'qualifiers': [],
                                                                             'type': None},
                                                              'returnType': None,
                                                              'static': False,
                                                              'typeQualifiers': {'thin_walled': ['const',
                                                                                                 '&']},
                                                              'types': {'thin_walled': 'bool'}}],
                                           'setTransmission': [{'argInfo': {'transmission': {'doc': 'value to which the attribute will be set.',
                                                                                             'type': 'float'}},
                                                                'args': [('transmission',
                                                                          'float',
                                                                          'in')],
                                                                'defaults': {},
                                                                'deprecated': False,
                                                                'doc': 'Sets the value of the "transmission" attribute of a shader node.',
                                                                'inArgs': ['transmission'],
                                                                'inverse': ('transmission',
                                                                            True),
                                                                'outArgs': [],
                                                                'returnInfo': {'doc': '',
                                                                               'qualifiers': [],
                                                                               'type': None},
                                                                'returnType': None,
                                                                'static': False,
                                                                'typeQualifiers': {'transmission': ['const',
                                                                                                    '&']},
                                                                'types': {'transmission': 'float'}}],
                                           'setTransmissionColor': [{'argInfo': {'transmission_color': {'doc': 'value to which the attribute will be set.',
                                                                                                        'type': 'MColor'}},
                                                                     'args': [('transmission_color',
                                                                               'MColor',
                                                                               'in')],
                                                                     'defaults': {},
                                                                     'deprecated': False,
                                                                     'doc': 'Sets the value of the "transmissionColor" attribute of a shader node.',
                                                                     'inArgs': ['transmission_color'],
                                                                     'inverse': ('transmissionColor',
                                                                                 True),
                                                                     'outArgs': [],
                                                                     'returnInfo': {'doc': '',
                                                                                    'qualifiers': [],
                                                                                    'type': None},
                                                                     'returnType': None,
                                                                     'static': False,
                                                                     'typeQualifiers': {'transmission_color': ['const',
                                                                                                               '&']},
                                                                     'types': {'transmission_color': 'MColor'}}],
                                           'setTransmissionDepth': [{'argInfo': {'transmission_depth': {'doc': 'value to which the attribute will be set.',
                                                                                                        'type': 'float'}},
                                                                     'args': [('transmission_depth',
                                                                               'float',
                                                                               'in')],
                                                                     'defaults': {},
                                                                     'deprecated': False,
                                                                     'doc': 'Sets the value of the "transmissionDepth" attribute of a shader node.',
                                                                     'inArgs': ['transmission_depth'],
                                                                     'inverse': ('transmissionDepth',
                                                                                 True),
                                                                     'outArgs': [],
                                                                     'returnInfo': {'doc': '',
                                                                                    'qualifiers': [],
                                                                                    'type': None},
                                                                     'returnType': None,
                                                                     'static': False,
                                                                     'typeQualifiers': {'transmission_depth': ['const',
                                                                                                               '&']},
                                                                     'types': {'transmission_depth': 'float'}}],
                                           'setTransmissionDispersion': [{'argInfo': {'transmission_dispersion': {'doc': 'value to which the attribute will be set.',
                                                                                                                  'type': 'float'}},
                                                                          'args': [('transmission_dispersion',
                                                                                    'float',
                                                                                    'in')],
                                                                          'defaults': {},
                                                                          'deprecated': False,
                                                                          'doc': 'Sets the value of the "transmissionDispersion" attribute of a shader node.',
                                                                          'inArgs': ['transmission_dispersion'],
                                                                          'inverse': ('transmissionDispersion',
                                                                                      True),
                                                                          'outArgs': [],
                                                                          'returnInfo': {'doc': '',
                                                                                         'qualifiers': [],
                                                                                         'type': None},
                                                                          'returnType': None,
                                                                          'static': False,
                                                                          'typeQualifiers': {'transmission_dispersion': ['const',
                                                                                                                         '&']},
                                                                          'types': {'transmission_dispersion': 'float'}}],
                                           'setTransmissionExtraRoughness': [{'argInfo': {'transmission_extra_roughness': {'doc': 'value to which the attribute will be set.',
                                                                                                                           'type': 'float'}},
                                                                              'args': [('transmission_extra_roughness',
                                                                                        'float',
                                                                                        'in')],
                                                                              'defaults': {},
                                                                              'deprecated': False,
                                                                              'doc': 'Sets the value of the "transmissionExtraRoughness" attribute of a shader node.',
                                                                              'inArgs': ['transmission_extra_roughness'],
                                                                              'inverse': ('transmissionExtraRoughness',
                                                                                          True),
                                                                              'outArgs': [],
                                                                              'returnInfo': {'doc': '',
                                                                                             'qualifiers': [],
                                                                                             'type': None},
                                                                              'returnType': None,
                                                                              'static': False,
                                                                              'typeQualifiers': {'transmission_extra_roughness': ['const',
                                                                                                                                  '&']},
                                                                              'types': {'transmission_extra_roughness': 'float'}}],
                                           'setTransmissionScatter': [{'argInfo': {'transmission_scatter': {'doc': 'value to which the attribute will be set.',
                                                                                                            'type': 'MColor'}},
                                                                       'args': [('transmission_scatter',
                                                                                 'MColor',
                                                                                 'in')],
                                                                       'defaults': {},
                                                                       'deprecated': False,
                                                                       'doc': 'Sets the value of the "transmissionScatter" attribute of a shader node.',
                                                                       'inArgs': ['transmission_scatter'],
                                                                       'inverse': ('transmissionScatter',
                                                                                   True),
                                                                       'outArgs': [],
                                                                       'returnInfo': {'doc': '',
                                                                                      'qualifiers': [],
                                                                                      'type': None},
                                                                       'returnType': None,
                                                                       'static': False,
                                                                       'typeQualifiers': {'transmission_scatter': ['const',
                                                                                                                   '&']},
                                                                       'types': {'transmission_scatter': 'MColor'}}],
                                           'setTransmissionScatterAnisotropy': [{'argInfo': {'transmission_scatter_anisotropy': {'doc': 'value to which the attribute will be set.',
                                                                                                                                 'type': 'float'}},
                                                                                 'args': [('transmission_scatter_anisotropy',
                                                                                           'float',
                                                                                           'in')],
                                                                                 'defaults': {},
                                                                                 'deprecated': False,
                                                                                 'doc': 'Sets the value of the "transmissionScatterAnisotropy" attribute of a shader node.',
                                                                                 'inArgs': ['transmission_scatter_anisotropy'],
                                                                                 'inverse': ('transmissionScatterAnisotropy',
                                                                                             True),
                                                                                 'outArgs': [],
                                                                                 'returnInfo': {'doc': '',
                                                                                                'qualifiers': [],
                                                                                                'type': None},
                                                                                 'returnType': None,
                                                                                 'static': False,
                                                                                 'typeQualifiers': {'transmission_scatter_anisotropy': ['const',
                                                                                                                                        '&']},
                                                                                 'types': {'transmission_scatter_anisotropy': 'float'}}],
                                           'sheen': [{'argInfo': {},
                                                      'args': [],
                                                      'defaults': {},
                                                      'deprecated': False,
                                                      'doc': 'Retrieves the value of the "sheen" attribute of a standard surface shader node.',
                                                      'inArgs': [],
                                                      'inverse': ('setSheen',
                                                                  False),
                                                      'outArgs': [],
                                                      'returnInfo': {'doc': 'The value of the "sheen" attribute of the shader node.',
                                                                     'qualifiers': [],
                                                                     'type': 'float'},
                                                      'returnType': 'float',
                                                      'static': False,
                                                      'typeQualifiers': {},
                                                      'types': {}}],
                                           'sheenColor': [{'argInfo': {},
                                                           'args': [],
                                                           'defaults': {},
                                                           'deprecated': False,
                                                           'doc': 'Retrieves the value of the "sheenColor" attribute of a standard surface shader node.',
                                                           'inArgs': [],
                                                           'inverse': ('setSheenColor',
                                                                       False),
                                                           'outArgs': [],
                                                           'returnInfo': {'doc': 'The value of the "sheenColor" attribute of the shader node.',
                                                                          'qualifiers': [],
                                                                          'type': 'MColor'},
                                                           'returnType': 'MColor',
                                                           'static': False,
                                                           'typeQualifiers': {},
                                                           'types': {}}],
                                           'sheenRoughness': [{'argInfo': {},
                                                               'args': [],
                                                               'defaults': {},
                                                               'deprecated': False,
                                                               'doc': 'Retrieves the value of the "sheenRoughness" attribute of a standard surface shader node.',
                                                               'inArgs': [],
                                                               'inverse': ('setSheenRoughness',
                                                                           False),
                                                               'outArgs': [],
                                                               'returnInfo': {'doc': 'The value of the "sheenRoughness" attribute of the shader node.',
                                                                              'qualifiers': [],
                                                                              'type': 'float'},
                                                               'returnType': 'float',
                                                               'static': False,
                                                               'typeQualifiers': {},
                                                               'types': {}}],
                                           'specular': [{'argInfo': {},
                                                         'args': [],
                                                         'defaults': {},
                                                         'deprecated': False,
                                                         'doc': 'Retrieves the value of the "specular" attribute of a standard surface shader node.',
                                                         'inArgs': [],
                                                         'inverse': ('setSpecular',
                                                                     False),
                                                         'outArgs': [],
                                                         'returnInfo': {'doc': 'The value of the "specular" attribute of the shader node.',
                                                                        'qualifiers': [],
                                                                        'type': 'float'},
                                                         'returnType': 'float',
                                                         'static': False,
                                                         'typeQualifiers': {},
                                                         'types': {}}],
                                           'specularAnisotropy': [{'argInfo': {},
                                                                   'args': [],
                                                                   'defaults': {},
                                                                   'deprecated': False,
                                                                   'doc': 'Retrieves the value of the "specularAnisotropy" attribute of a standard surface shader node.',
                                                                   'inArgs': [],
                                                                   'inverse': ('setSpecularAnisotropy',
                                                                               False),
                                                                   'outArgs': [],
                                                                   'returnInfo': {'doc': 'The value of the "specularAnisotropy" attribute of the shader node.',
                                                                                  'qualifiers': [],
                                                                                  'type': 'float'},
                                                                   'returnType': 'float',
                                                                   'static': False,
                                                                   'typeQualifiers': {},
                                                                   'types': {}}],
                                           'specularColor': [{'argInfo': {},
                                                              'args': [],
                                                              'defaults': {},
                                                              'deprecated': False,
                                                              'doc': 'Retrieves the value of the "specularColor" attribute of a standard surface shader node.',
                                                              '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': {},
                                                              'types': {}}],
                                           'specularIOR': [{'argInfo': {},
                                                            'args': [],
                                                            'defaults': {},
                                                            'deprecated': False,
                                                            'doc': 'Retrieves the value of the "specularIOR" attribute of a standard surface shader node.',
                                                            'inArgs': [],
                                                            'inverse': ('setSpecularIOR',
                                                                        False),
                                                            'outArgs': [],
                                                            'returnInfo': {'doc': 'The value of the "specularIOR" attribute of the shader node.',
                                                                           'qualifiers': [],
                                                                           'type': 'float'},
                                                            'returnType': 'float',
                                                            'static': False,
                                                            'typeQualifiers': {},
                                                            'types': {}}],
                                           'specularRotation': [{'argInfo': {},
                                                                 'args': [],
                                                                 'defaults': {},
                                                                 'deprecated': False,
                                                                 'doc': 'Retrieves the value of the "specularRotation" attribute of a standard surface shader node.',
                                                                 'inArgs': [],
                                                                 'inverse': ('setSpecularRotation',
                                                                             False),
                                                                 'outArgs': [],
                                                                 'returnInfo': {'doc': 'The value of the "specularRotation" attribute of the shader node.',
                                                                                'qualifiers': [],
                                                                                'type': 'float'},
                                                                 'returnType': 'float',
                                                                 'static': False,
                                                                 'typeQualifiers': {},
                                                                 'types': {}}],
                                           'specularRoughness': [{'argInfo': {},
                                                                  'args': [],
                                                                  'defaults': {},
                                                                  'deprecated': False,
                                                                  'doc': 'Retrieves the value of the "specularRoughness" attribute of a standard surface shader node.',
                                                                  'inArgs': [],
                                                                  'inverse': ('setSpecularRoughness',
                                                                              False),
                                                                  'outArgs': [],
                                                                  'returnInfo': {'doc': 'The value of the "specularRoughness" attribute of the shader node.',
                                                                                 'qualifiers': [],
                                                                                 'type': 'float'},
                                                                  'returnType': 'float',
                                                                  'static': False,
                                                                  'typeQualifiers': {},
                                                                  'types': {}}],
                                           'subsurface': [{'argInfo': {},
                                                           'args': [],
                                                           'defaults': {},
                                                           'deprecated': False,
                                                           'doc': 'Retrieves the value of the "subsurface" attribute of a standard surface shader node.',
                                                           'inArgs': [],
                                                           'inverse': ('setSubsurface',
                                                                       False),
                                                           'outArgs': [],
                                                           'returnInfo': {'doc': 'The value of the "subsurface" attribute of the shader node.',
                                                                          'qualifiers': [],
                                                                          'type': 'float'},
                                                           'returnType': 'float',
                                                           'static': False,
                                                           'typeQualifiers': {},
                                                           'types': {}}],
                                           'subsurfaceAnisotropy': [{'argInfo': {},
                                                                     'args': [],
                                                                     'defaults': {},
                                                                     'deprecated': False,
                                                                     'doc': 'Retrieves the value of the "subsurfaceAnisotropy" attribute of a standard surface shader node.',
                                                                     'inArgs': [],
                                                                     'inverse': ('setSubsurfaceAnisotropy',
                                                                                 False),
                                                                     'outArgs': [],
                                                                     'returnInfo': {'doc': 'The value of the "subsurfaceAnisotropy" attribute of the shader node.',
                                                                                    'qualifiers': [],
                                                                                    'type': 'float'},
                                                                     'returnType': 'float',
                                                                     'static': False,
                                                                     'typeQualifiers': {},
                                                                     'types': {}}],
                                           'subsurfaceColor': [{'argInfo': {},
                                                                'args': [],
                                                                'defaults': {},
                                                                'deprecated': False,
                                                                'doc': 'Retrieves the value of the "subsurfaceColor" attribute of a standard surface shader node.',
                                                                'inArgs': [],
                                                                'inverse': ('setSubsurfaceColor',
                                                                            False),
                                                                'outArgs': [],
                                                                'returnInfo': {'doc': 'The value of the "subsurfaceColor" attribute of the shader node.',
                                                                               'qualifiers': [],
                                                                               'type': 'MColor'},
                                                                'returnType': 'MColor',
                                                                'static': False,
                                                                'typeQualifiers': {},
                                                                'types': {}}],
                                           'subsurfaceRadius': [{'argInfo': {},
                                                                 'args': [],
                                                                 'defaults': {},
                                                                 'deprecated': False,
                                                                 'doc': 'Retrieves the value of the "subsurfaceRadius" attribute of a standard surface shader node.',
                                                                 'inArgs': [],
                                                                 'inverse': ('setSubsurfaceRadius',
                                                                             False),
                                                                 'outArgs': [],
                                                                 'returnInfo': {'doc': 'The value of the "subsurfaceRadius" attribute of the shader node.',
                                                                                'qualifiers': [],
                                                                                'type': 'MColor'},
                                                                 'returnType': 'MColor',
                                                                 'static': False,
                                                                 'typeQualifiers': {},
                                                                 'types': {}}],
                                           'subsurfaceScale': [{'argInfo': {},
                                                                'args': [],
                                                                'defaults': {},
                                                                'deprecated': False,
                                                                'doc': 'Retrieves the value of the "subsurfaceScale" attribute of a standard surface shader node.',
                                                                'inArgs': [],
                                                                'inverse': ('setSubsurfaceScale',
                                                                            False),
                                                                'outArgs': [],
                                                                'returnInfo': {'doc': 'The value of the "subsurfaceScale" attribute of the shader node.',
                                                                               'qualifiers': [],
                                                                               'type': 'float'},
                                                                'returnType': 'float',
                                                                'static': False,
                                                                'typeQualifiers': {},
                                                                'types': {}}],
                                           'thinFilmIOR': [{'argInfo': {},
                                                            'args': [],
                                                            'defaults': {},
                                                            'deprecated': False,
                                                            'doc': 'Retrieves the value of the "thinFilmIOR" attribute of a standard surface shader node.',
                                                            'inArgs': [],
                                                            'inverse': ('setThinFilmIOR',
                                                                        False),
                                                            'outArgs': [],
                                                            'returnInfo': {'doc': 'The value of the "thinFilmIOR" attribute of the shader node.',
                                                                           'qualifiers': [],
                                                                           'type': 'float'},
                                                            'returnType': 'float',
                                                            'static': False,
                                                            'typeQualifiers': {},
                                                            'types': {}}],
                                           'thinFilmThickness': [{'argInfo': {},
                                                                  'args': [],
                                                                  'defaults': {},
                                                                  'deprecated': False,
                                                                  'doc': 'Retrieves the value of the "thinFilmThickness" attribute of a standard surface shader node.',
                                                                  'inArgs': [],
                                                                  'inverse': ('setThinFilmThickness',
                                                                              False),
                                                                  'outArgs': [],
                                                                  'returnInfo': {'doc': 'The value of the "thinFilmThickness" attribute of the shader node.',
                                                                                 'qualifiers': [],
                                                                                 'type': 'float'},
                                                                  'returnType': 'float',
                                                                  'static': False,
                                                                  'typeQualifiers': {},
                                                                  'types': {}}],
                                           'thinWalled': [{'argInfo': {},
                                                           'args': [],
                                                           'defaults': {},
                                                           'deprecated': False,
                                                           'doc': 'Retrieves the value of the "thinWalled" attribute of a standard surface shader node.',
                                                           'inArgs': [],
                                                           'inverse': ('setThinWalled',
                                                                       False),
                                                           'outArgs': [],
                                                           'returnInfo': {'doc': 'The value of the "thinWalled" attribute of the shader node.',
                                                                          'qualifiers': [],
                                                                          'type': 'bool'},
                                                           'returnType': 'bool',
                                                           'static': False,
                                                           'typeQualifiers': {},
                                                           'types': {}}],
                                           'transmission': [{'argInfo': {},
                                                             'args': [],
                                                             'defaults': {},
                                                             'deprecated': False,
                                                             'doc': 'Retrieves the value of the "transmission" attribute of a standard surface shader node.',
                                                             'inArgs': [],
                                                             'inverse': ('setTransmission',
                                                                         False),
                                                             'outArgs': [],
                                                             'returnInfo': {'doc': 'The value of the "transmission" attribute of the shader node.',
                                                                            'qualifiers': [],
                                                                            'type': 'float'},
                                                             'returnType': 'float',
                                                             'static': False,
                                                             'typeQualifiers': {},
                                                             'types': {}}],
                                           'transmissionColor': [{'argInfo': {},
                                                                  'args': [],
                                                                  'defaults': {},
                                                                  'deprecated': False,
                                                                  'doc': 'Retrieves the value of the "transmissionColor" attribute of a standard surface shader node.',
                                                                  'inArgs': [],
                                                                  'inverse': ('setTransmissionColor',
                                                                              False),
                                                                  'outArgs': [],
                                                                  'returnInfo': {'doc': 'The value of the "transmissionColor" attribute of the shader node.',
                                                                                 'qualifiers': [],
                                                                                 'type': 'MColor'},
                                                                  'returnType': 'MColor',
                                                                  'static': False,
                                                                  'typeQualifiers': {},
                                                                  'types': {}}],
                                           'transmissionDepth': [{'argInfo': {},
                                                                  'args': [],
                                                                  'defaults': {},
                                                                  'deprecated': False,
                                                                  'doc': 'Retrieves the value of the "transmissionDepth" attribute of a standard surface shader node.',
                                                                  'inArgs': [],
                                                                  'inverse': ('setTransmissionDepth',
                                                                              False),
                                                                  'outArgs': [],
                                                                  'returnInfo': {'doc': 'The value of the "transmissionDepth" attribute of the shader node.',
                                                                                 'qualifiers': [],
                                                                                 'type': 'float'},
                                                                  'returnType': 'float',
                                                                  'static': False,
                                                                  'typeQualifiers': {},
                                                                  'types': {}}],
                                           'transmissionDispersion': [{'argInfo': {},
                                                                       'args': [],
                                                                       'defaults': {},
                                                                       'deprecated': False,
                                                                       'doc': 'Retrieves the value of the "transmissionDispersion" attribute of a standard surface shader node.',
                                                                       'inArgs': [],
                                                                       'inverse': ('setTransmissionDispersion',
                                                                                   False),
                                                                       'outArgs': [],
                                                                       'returnInfo': {'doc': 'The value of the "transmissionDispersion" attribute of the shader node.',
                                                                                      'qualifiers': [],
                                                                                      'type': 'float'},
                                                                       'returnType': 'float',
                                                                       'static': False,
                                                                       'typeQualifiers': {},
                                                                       'types': {}}],
                                           'transmissionExtraRoughness': [{'argInfo': {},
                                                                           'args': [],
                                                                           'defaults': {},
                                                                           'deprecated': False,
                                                                           'doc': 'Retrieves the value of the "transmissionExtraRoughness" attribute of a standard surface shader node.',
                                                                           'inArgs': [],
                                                                           'inverse': ('setTransmissionExtraRoughness',
                                                                                       False),
                                                                           'outArgs': [],
                                                                           'returnInfo': {'doc': 'The value of the "transmissionExtraRoughness" attribute of the shader node.',
                                                                                          'qualifiers': [],
                                                                                          'type': 'float'},
                                                                           'returnType': 'float',
                                                                           'static': False,
                                                                           'typeQualifiers': {},
                                                                           'types': {}}],
                                           'transmissionScatter': [{'argInfo': {},
                                                                    'args': [],
                                                                    'defaults': {},
                                                                    'deprecated': False,
                                                                    'doc': 'Retrieves the value of the "transmissionScatter" attribute of a standard surface shader node.',
                                                                    'inArgs': [],
                                                                    'inverse': ('setTransmissionScatter',
                                                                                False),
                                                                    'outArgs': [],
                                                                    'returnInfo': {'doc': 'The value of the "transmissionScatter" attribute of the shader node.',
                                                                                   'qualifiers': [],
                                                                                   'type': 'MColor'},
                                                                    'returnType': 'MColor',
                                                                    'static': False,
                                                                    'typeQualifiers': {},
                                                                    'types': {}}],
                                           'transmissionScatterAnisotropy': [{'argInfo': {},
                                                                              'args': [],
                                                                              'defaults': {},
                                                                              'deprecated': False,
                                                                              'doc': 'Retrieves the value of the "transmissionScatterAnisotropy" attribute of a standard surface shader node.',
                                                                              'inArgs': [],
                                                                              'inverse': ('setTransmissionScatterAnisotropy',
                                                                                          False),
                                                                              'outArgs': [],
                                                                              'returnInfo': {'doc': 'The value of the "transmissionScatterAnisotropy" attribute of the shader node.',
                                                                                             'qualifiers': [],
                                                                                             'type': 'float'},
                                                                              'returnType': 'float',
                                                                              'static': False,
                                                                              'typeQualifiers': {},
                                                                              'types': {}}],
                                           'type': [{'argInfo': {},
                                                     'args': [],
                                                     'defaults': {},
                                                     'deprecated': False,
                                                     'doc': 'Function set type',
                                                     'inArgs': [],
                                                     'outArgs': [],
                                                     'returnInfo': {'doc': 'the class type.',
                                                                    'qualifiers': [],
                                                                    'type': ('MFn',
                                                                             'Type')},
                                                     'returnType': ('MFn',
                                                                    'Type'),
                                                     'static': False,
                                                     'typeQualifiers': {},
                                                     'types': {}}]},
                               'pymelEnums': {},
                               'pymelMethods': {'base': 'getBase',
                                                'baseColor': 'getBaseColor',
                                                'coat': 'getCoat',
                                                'coatAffectColor': 'getCoatAffectColor',
                                                'coatAffectRoughness': 'getCoatAffectRoughness',
                                                'coatAnisotropy': 'getCoatAnisotropy',
                                                'coatColor': 'getCoatColor',
                                                'coatIOR': 'getCoatIOR',
                                                'coatRotation': 'getCoatRotation',
                                                'coatRoughness': 'getCoatRoughness',
                                                'diffuseRoughness': 'getDiffuseRoughness',
                                                'emission': 'getEmission',
                                                'emissionColor': 'getEmissionColor',
                                                'metalness': 'getMetalness',
                                                'opacity': 'getOpacity',
                                                'sheen': 'getSheen',
                                                'sheenColor': 'getSheenColor',
                                                'sheenRoughness': 'getSheenRoughness',
                                                'specular': 'getSpecular',
                                                'specularAnisotropy': 'getSpecularAnisotropy',
                                                'specularColor': 'getSpecularColor',
                                                'specularIOR': 'getSpecularIOR',
                                                'specularRotation': 'getSpecularRotation',
                                                'specularRoughness': 'getSpecularRoughness',
                                                'subsurface': 'getSubsurface',
                                                'subsurfaceAnisotropy': 'getSubsurfaceAnisotropy',
                                                'subsurfaceColor': 'getSubsurfaceColor',
                                                'subsurfaceRadius': 'getSubsurfaceRadius',
                                                'subsurfaceScale': 'getSubsurfaceScale',
                                                'thinFilmIOR': 'getThinFilmIOR',
                                                'thinFilmThickness': 'getThinFilmThickness',
                                                'thinWalled': 'getThinWalled',
                                                'transmission': 'getTransmission',
                                                'transmissionColor': 'getTransmissionColor',
                                                'transmissionDepth': 'getTransmissionDepth',
                                                'transmissionDispersion': 'getTransmissionDispersion',
                                                'transmissionExtraRoughness': 'getTransmissionExtraRoughness',
                                                'transmissionScatter': 'getTransmissionScatter',
                                                'transmissionScatterAnisotropy': 'getTransmissionScatterAnisotropy'}},
  'MFnStateManip': {'enums': {},
                    'invertibles': [('setMaxStates', 'maxStates')],
                    'methods': {'className': [{'argInfo': {},
                                               'args': [],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': 'Returns the name of this class.',
                                               'inArgs': [],
                                               'outArgs': [],
                                               'returnInfo': {'doc': 'Name of this class.',
                                                              'qualifiers': ['*'],
                                                              'type': 'char'},
                                               'returnType': 'char',
                                               'static': True,
                                               'typeQualifiers': {},
                                               'types': {}}],
                                'connectToStatePlug': [{'argInfo': {'statePlug': {'doc': 'the state plug',
                                                                                  'type': 'MPlug'}},
                                                        'args': [('statePlug',
                                                                  'MPlug',
                                                                  'in')],
                                                        'defaults': {},
                                                        'deprecated': False,
                                                        'doc': 'Connect 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': "Creates 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': {},
                                            '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': "Creates 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': {'manipName': ['const',
                                                                             '&'],
                                                               'stateName': ['const',
                                                                             '&']},
                                            'types': {'manipName': 'MString',
                                                      'stateName': 'MString'}}],
                                'maxStates': [{'argInfo': {},
                                               'args': [],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': 'Returns the number of maximum states.',
                                               'inArgs': [],
                                               'inverse': ('setMaxStates',
                                                           False),
                                               'outArgs': [],
                                               'returnInfo': {'doc': 'Maximum states',
                                                              'qualifiers': [],
                                                              'type': 'uint'},
                                               'returnType': 'uint',
                                               'static': False,
                                               'typeQualifiers': {},
                                               'types': {}}],
                                'positionIndex': [{'argInfo': {},
                                                   'args': [],
                                                   'defaults': {},
                                                   'deprecated': False,
                                                   'doc': 'Returns 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': 'uint'},
                                                   'returnType': 'uint',
                                                   'static': False,
                                                   'typeQualifiers': {},
                                                   'types': {}}],
                                'setInitialState': [{'argInfo': {'initialState': {'doc': 'initial state of the StateManip',
                                                                                  'type': 'uint'}},
                                                     'args': [('initialState',
                                                               'uint',
                                                               'in')],
                                                     'defaults': {},
                                                     'deprecated': False,
                                                     'doc': 'Sets 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': 'Sets 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': 'Returns the current state.',
                                           'inArgs': [],
                                           'outArgs': [],
                                           'returnInfo': {'doc': 'Current states',
                                                          'qualifiers': [],
                                                          'type': 'uint'},
                                           'returnType': 'uint',
                                           'static': False,
                                           'typeQualifiers': {},
                                           'types': {}}],
                                'stateIndex': [{'argInfo': {},
                                                'args': [],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': 'Returns the index of the state. The data type corresponding to this index is a int integer.',
                                                'inArgs': [],
                                                'outArgs': [],
                                                'returnInfo': {'doc': 'State index',
                                                               'qualifiers': [],
                                                               'type': 'uint'},
                                                'returnType': 'uint',
                                                'static': False,
                                                'typeQualifiers': {},
                                                'types': {}}],
                                'type': [{'argInfo': {},
                                          'args': [],
                                          'defaults': {},
                                          'deprecated': False,
                                          'doc': 'Function set type',
                                          'inArgs': [],
                                          'outArgs': [],
                                          'returnInfo': {'doc': 'the class type.',
                                                         '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': 'Extract 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'}}],
                                     'array': [{'argInfo': {},
                                                'args': [],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': 'Return 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': {},
                                                'types': {}}],
                                     'className': [{'argInfo': {},
                                                    'args': [],
                                                    'defaults': {},
                                                    'deprecated': False,
                                                    'doc': 'Returns the name of this class.',
                                                    'inArgs': [],
                                                    'outArgs': [],
                                                    'returnInfo': {'doc': 'Name of this class.',
                                                                   'qualifiers': ['*'],
                                                                   'type': 'char'},
                                                    'returnType': 'char',
                                                    'static': True,
                                                    'typeQualifiers': {},
                                                    'types': {}}],
                                     'copyTo': [{'argInfo': {'dest': {'doc': 'the MStringArray to populate',
                                                                      'type': 'MStringArray'}},
                                                 'args': [('dest',
                                                           'MStringArray',
                                                           'out')],
                                                 'defaults': {},
                                                 'deprecated': False,
                                                 'doc': 'Copy 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': 'Create 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': {},
                                                 'types': {}},
                                                {'argInfo': {'arr': {'doc': 'the data to use when initializing this instance',
                                                                     'type': 'MStringArray'}},
                                                 'args': [('arr',
                                                           'MStringArray',
                                                           'in')],
                                                 'defaults': {},
                                                 'deprecated': False,
                                                 'doc': 'Create 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': {'arr': ['const',
                                                                            '&']},
                                                 'types': {'arr': 'MStringArray'}}],
                                     'length': [{'argInfo': {},
                                                 'args': [],
                                                 'defaults': {},
                                                 'deprecated': False,
                                                 'doc': 'Return the number of strings in the instance.',
                                                 'inArgs': [],
                                                 'outArgs': [],
                                                 'returnInfo': {'doc': 'The number of strings in the instance',
                                                                'qualifiers': [],
                                                                'type': 'uint'},
                                                 'returnType': 'uint',
                                                 'static': False,
                                                 'typeQualifiers': {},
                                                 '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': 'Set 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': 'Set 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': 'Function set type',
                                               'inArgs': [],
                                               'outArgs': [],
                                               'returnInfo': {'doc': 'the class type.',
                                                              'qualifiers': [],
                                                              'type': ('MFn',
                                                                       'Type')},
                                               'returnType': ('MFn', 'Type'),
                                               'static': False,
                                               'typeQualifiers': {},
                                               'types': {}}]},
                         'pymelEnums': {}},
  'MFnStringData': {'enums': {},
                    'methods': {'className': [{'argInfo': {},
                                               'args': [],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': 'Returns the name of this class.',
                                               'inArgs': [],
                                               'outArgs': [],
                                               'returnInfo': {'doc': 'Name of this class.',
                                                              'qualifiers': ['*'],
                                                              'type': 'char'},
                                               'returnType': 'char',
                                               'static': True,
                                               'typeQualifiers': {},
                                               'types': {}}],
                                'create': [{'argInfo': {'str': {'doc': 'the string to copy',
                                                                'type': 'MString'}},
                                            'args': [('str', 'MString', 'in')],
                                            'defaults': {},
                                            'deprecated': False,
                                            'doc': 'Create 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': {'str': ['const',
                                                                       '&']},
                                            'types': {'str': 'MString'}},
                                           {'argInfo': {},
                                            'args': [],
                                            'defaults': {},
                                            'deprecated': False,
                                            'doc': 'Create 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': {},
                                            'types': {}}],
                                'set': [{'argInfo': {'string': {'doc': 'the MString to copy',
                                                                'type': 'MString'}},
                                         'args': [('string', 'MString', 'in')],
                                         'defaults': {},
                                         'deprecated': False,
                                         'doc': 'Set 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': 'Return 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': {},
                                            'types': {}}],
                                'type': [{'argInfo': {},
                                          'args': [],
                                          'defaults': {},
                                          'deprecated': False,
                                          'doc': 'Function set type',
                                          'inArgs': [],
                                          'outArgs': [],
                                          'returnInfo': {'doc': 'the class type.',
                                                         'qualifiers': [],
                                                         'type': ('MFn',
                                                                  'Type')},
                                          'returnType': ('MFn', 'Type'),
                                          'static': False,
                                          'typeQualifiers': {},
                                          'types': {}}]},
                    'pymelEnums': {}},
  'MFnSubd': {'enums': {},
              'methods': {'className': [{'argInfo': {},
                                         'args': [],
                                         'defaults': {},
                                         'deprecated': False,
                                         'doc': 'Returns the name of this class.',
                                         'inArgs': [],
                                         'outArgs': [],
                                         'returnInfo': {'doc': 'Name of this class.',
                                                        'qualifiers': ['*'],
                                                        'type': 'char'},
                                         'returnType': 'char',
                                         'static': True,
                                         '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': 'This 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': {'level': ['const']},
                                        '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': 'Converts 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': 'This 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': {'source': ['const',
                                                                  '&']},
                                    'types': {'parentOrOwner': 'MObject',
                                              'source': 'MObject'}}],
                          'creasesClearAll': [{'argInfo': {},
                                               'args': [],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': 'Clear 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': 'Returns 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': 'Set 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': 'Creates 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': {'polygonConnects': ['const',
                                                                                     '&'],
                                                                 'polygonCounts': ['const',
                                                                                   '&'],
                                                                 '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': 'Return 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': {'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': "Return 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': {},
                                           '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': 'Returns 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': ['&']},
                                            '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': 'Returns the number of edges at a level.',
                                         'inArgs': ['level'],
                                         'outArgs': [],
                                         'returnInfo': {'doc': 'Number of edges at the given level',
                                                        'qualifiers': [],
                                                        'type': 'uint'},
                                         'returnType': 'uint',
                                         'static': False,
                                         'typeQualifiers': {},
                                         'types': {'level': 'int'}}],
                          'edgeCreaseRelevant': [{'argInfo': {'edgeId': {'doc': 'The edge 64-bit name',
                                                                         'type': 'MUint64'}},
                                                  'args': [('edgeId',
                                                            'MUint64',
                                                            'in')],
                                                  'defaults': {},
                                                  'deprecated': False,
                                                  'doc': 'Return 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': {},
                                                  'types': {'edgeId': 'MUint64'}}],
                          'edgeIsBoundary': [{'argInfo': {'edgeId': {'doc': 'The 64-bit edge name',
                                                                     'type': 'MUint64'}},
                                              'args': [('edgeId',
                                                        'MUint64',
                                                        'in')],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': 'Test 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': {},
                                              'types': {'edgeId': 'MUint64'}}],
                          'edgeIsCreased': [{'argInfo': {'edgeId': {'doc': 'The 64-bit name of the edge',
                                                                    'type': 'MUint64'}},
                                             'args': [('edgeId',
                                                       'MUint64',
                                                       'in')],
                                             'defaults': {},
                                             'deprecated': False,
                                             'doc': 'Return 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': {},
                                             'types': {'edgeId': 'MUint64'}}],
                          'edgeIsValid': [{'argInfo': {'edgeId': {'doc': 'The 64-bit edge name',
                                                                  'type': 'MUint64'}},
                                           'args': [('edgeId',
                                                     'MUint64',
                                                     'in')],
                                           'defaults': {},
                                           'deprecated': False,
                                           'doc': 'Returns 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': {},
                                           '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': "Set the particular edge's crease state.",
                                             'inArgs': ['edgeId', 'creased'],
                                             'outArgs': [],
                                             'returnInfo': {'doc': '',
                                                            'qualifiers': [],
                                                            'type': None},
                                             'returnType': None,
                                             'static': False,
                                             'typeQualifiers': {},
                                             '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': 'Given an edge, return the two vertices at its ends.',
                                            'inArgs': ['edgeId'],
                                            'outArgs': ['v1', 'v2'],
                                            'returnInfo': {'doc': '',
                                                           'qualifiers': [],
                                                           'type': None},
                                            'returnType': None,
                                            'static': False,
                                            'typeQualifiers': {'v1': ['&'],
                                                               'v2': ['&']},
                                            'types': {'edgeId': 'MUint64',
                                                      'v1': 'MUint64',
                                                      'v2': 'MUint64'}}],
                          'editsPending': [{'argInfo': {},
                                            'args': [],
                                            'defaults': {},
                                            'deprecated': False,
                                            'doc': 'As 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': {},
                                            'types': {}}],
                          'editsUpdateAll': [{'argInfo': {},
                                              'args': [],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': 'If 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': {},
                                              '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': 'Evaluate 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': ['&']},
                                              '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': 'Evaluate 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': {'pos': ['&']},
                                                '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': 'Evaluate 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': ['&'],
                                                                            'pos': ['&']},
                                                         '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': 'Returns 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': 'Some 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': {},
                                              'types': {'polyId': 'MUint64',
                                                        'vertices': 'MPointArray'}}],
                          'levelFullySubdivideTo': [{'argInfo': {'level': {'doc': 'The level to which to fully subdivide',
                                                                           'type': 'int'}},
                                                     'args': [('level',
                                                               'int',
                                                               'in')],
                                                     'defaults': {},
                                                     'deprecated': False,
                                                     'doc': 'Fully 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': {},
                                                     'types': {'level': 'int'}}],
                          'levelMaxAllowed': [{'argInfo': {},
                                               'args': [],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': 'Returns 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': 'uint'},
                                               'returnType': 'uint',
                                               'static': False,
                                               'typeQualifiers': {},
                                               'types': {}}],
                          'levelMaxCurrent': [{'argInfo': {},
                                               'args': [],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': 'Returns 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': 'uint'},
                                               'returnType': 'uint',
                                               'static': False,
                                               'typeQualifiers': {},
                                               'types': {}}],
                          'objectChanged': [{'argInfo': {'tp': {'doc': '',
                                                                'type': ('MFn',
                                                                         'Type')}},
                                             'args': [('tp',
                                                       ('MFn', 'Type'),
                                                       'in')],
                                             'defaults': {},
                                             'deprecated': False,
                                             'doc': '',
                                             'inArgs': ['tp'],
                                             'outArgs': [],
                                             'returnInfo': {'doc': '',
                                                            'qualifiers': [],
                                                            'type': 'bool'},
                                             'returnType': 'bool',
                                             'static': False,
                                             'typeQualifiers': {},
                                             'types': {'tp': ('MFn', 'Type')}}],
                          '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': 'Add 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': {'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': 'Add 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': {'uValues': ['const'],
                                                                            'vValues': ['const'],
                                                                            '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': 'Returns 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': ['&']},
                                               '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': 'Returns 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': 'uint'},
                                            'returnType': 'uint',
                                            'static': False,
                                            'typeQualifiers': {},
                                            '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': 'If 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': {},
                                                                'types': {'level': 'int'}}],
                          'polygonEdgeCount': [{'argInfo': {'polyId': {'doc': 'The 64-bit name of the polygon',
                                                                       'type': 'MUint64'}},
                                                'args': [('polyId',
                                                          'MUint64',
                                                          'in')],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': 'The number of edges on the given polygon.',
                                                'inArgs': ['polyId'],
                                                'outArgs': [],
                                                'returnInfo': {'doc': 'The number of edges on this polygon',
                                                               'qualifiers': [],
                                                               'type': 'uint'},
                                                'returnType': 'uint',
                                                'static': False,
                                                'typeQualifiers': {},
                                                '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': 'Given 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': ['&']},
                                            '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': 'Return the UV values in the "center" of this polygon.',
                                                  'inArgs': ['polyId'],
                                                  'outArgs': ['u', 'v'],
                                                  'returnInfo': {'doc': '',
                                                                 'qualifiers': [],
                                                                 'type': None},
                                                  'returnType': None,
                                                  'static': False,
                                                  'typeQualifiers': {'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': 'Get 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': {'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': 'Returns 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': {},
                                                  'types': {'polyId': 'MUint64'}}],
                          'polygonHasVertexUVs': [{'argInfo': {'polyId': {'doc': 'The 64-bit polygon name',
                                                                          'type': 'MUint64'}},
                                                   'args': [('polyId',
                                                             'MUint64',
                                                             'in')],
                                                   'defaults': {},
                                                   'deprecated': False,
                                                   'doc': 'Returns 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': {},
                                                   'types': {'polyId': 'MUint64'}}],
                          'polygonIsValid': [{'argInfo': {'polygonId': {'doc': 'The polygon 64-bit name',
                                                                        'type': 'MUint64'}},
                                              'args': [('polygonId',
                                                        'MUint64',
                                                        'in')],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': 'Return 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': {},
                                              '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': 'If 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': {},
                                                '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': 'Set the UV values on the polygon.',
                                                   'inArgs': ['polyId',
                                                              'uValues',
                                                              'vValues'],
                                                   'outArgs': [],
                                                   'returnInfo': {'doc': '',
                                                                  'qualifiers': [],
                                                                  'type': None},
                                                   'returnType': None,
                                                   'static': False,
                                                   'typeQualifiers': {'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': 'Subdivide 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': {},
                                                'types': {'polyId': 'MUint64'}}],
                          'polygonVertexCount': [{'argInfo': {'polyId': {'doc': 'The 64-bit name of the polygon',
                                                                         'type': 'MUint64'}},
                                                  'args': [('polyId',
                                                            'MUint64',
                                                            'in')],
                                                  'defaults': {},
                                                  'deprecated': False,
                                                  'doc': 'How 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': 'uint'},
                                                  'returnType': 'uint',
                                                  'static': False,
                                                  'typeQualifiers': {},
                                                  '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': 'Given 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': {'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': 'Performs 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': {},
                                         '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': 'Performs 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': {},
                                                  'types': {'parentOrOwner': 'MObject'}}],
                          'type': [{'argInfo': {},
                                    'args': [],
                                    'defaults': {},
                                    'deprecated': False,
                                    'doc': 'Function set type',
                                    'inArgs': [],
                                    'outArgs': [],
                                    'returnInfo': {'doc': 'the class type.',
                                                   'qualifiers': [],
                                                   'type': ('MFn', 'Type')},
                                    'returnType': ('MFn', 'Type'),
                                    'static': False,
                                    'typeQualifiers': {},
                                    'types': {}}],
                          'updateAllEditsAndCreases': [{'argInfo': {},
                                                        'args': [],
                                                        'defaults': {},
                                                        'deprecated': False,
                                                        'doc': 'If 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': 'Signal 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': 'Return 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': ['&']},
                                                      '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': 'Given 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': {},
                                                           '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': 'Add 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': {},
                                                 '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': 'Very 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': {},
                                                          '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': 'Return 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': ['&']},
                                                 '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': 'Return 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': ['&'],
                                                                          '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': 'Set 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',
                                                                                  '&']},
                                                 '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': 'Set 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',
                                                                                        '&'],
                                                                          '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': 'Returns 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': ['&']},
                                              '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': 'Returns 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': 'uint'},
                                           'returnType': 'uint',
                                           'static': False,
                                           'typeQualifiers': {},
                                           'types': {'level': 'int'}}],
                          'vertexCreaseRelevant': [{'argInfo': {'vertexId': {'doc': 'The vertex 64-bit name',
                                                                             'type': 'MUint64'}},
                                                    'args': [('vertexId',
                                                              'MUint64',
                                                              'in')],
                                                    'defaults': {},
                                                    'deprecated': False,
                                                    'doc': 'Return 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': {},
                                                    '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': 'Get 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': ['&']},
                                             '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': 'Set 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',
                                                                         '&']},
                                             'types': {'edit': 'MVector',
                                                       'space': ('MSpace',
                                                                 'Space'),
                                                       'updateEdits': 'bool',
                                                       'vertexId': 'MUint64'}}],
                          'vertexEditsClearAllNonBase': [{'argInfo': {},
                                                          'args': [],
                                                          'defaults': {},
                                                          'deprecated': False,
                                                          'doc': 'Find 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': 'Returns 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': ['&'],
                                                                           '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': 'Given 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',
                                                                                     '&'],
                                                                           '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': 'Vertices 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': {},
                                                           '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': 'Return 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': ['&']},
                                                   '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': 'Return 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': ['&']},
                                                      'types': {'polyList': 'MUint64Array',
                                                                'vertexId': 'MUint64'}}],
                          'vertexIsBoundary': [{'argInfo': {'vertexId': {'doc': 'The vertex 64-bit name',
                                                                         'type': 'MUint64'}},
                                                'args': [('vertexId',
                                                          'MUint64',
                                                          'in')],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': 'Return 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': {},
                                                'types': {'vertexId': 'MUint64'}}],
                          'vertexIsCreased': [{'argInfo': {'vertexId': {'doc': 'The vertex 64-bit name',
                                                                        'type': 'MUint64'}},
                                               'args': [('vertexId',
                                                         'MUint64',
                                                         'in')],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': 'Return 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': {},
                                               'types': {'vertexId': 'MUint64'}}],
                          'vertexIsValid': [{'argInfo': {'vertexId': {'doc': 'The vertex 64-bit name',
                                                                      'type': 'MUint64'}},
                                             'args': [('vertexId',
                                                       'MUint64',
                                                       'in')],
                                             'defaults': {},
                                             'deprecated': False,
                                             'doc': 'Return 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': {},
                                             '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': 'Returns the normal at the vertex',
                                            'inArgs': ['vertexId'],
                                            'outArgs': ['normal'],
                                            'returnInfo': {'doc': '',
                                                           'qualifiers': [],
                                                           'type': None},
                                            'returnType': None,
                                            'static': False,
                                            'typeQualifiers': {'normal': ['&']},
                                            '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': 'Get 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': ['&']},
                                                 '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': 'What 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': ['&']},
                                                       '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': 'Set 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',
                                                                                 '&']},
                                                 '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': "Set the particular vertex' crease state.",
                                               'inArgs': ['vertexId',
                                                          'creased'],
                                               'outArgs': [],
                                               'returnInfo': {'doc': '',
                                                              'qualifiers': [],
                                                              'type': None},
                                               'returnType': None,
                                               'static': False,
                                               'typeQualifiers': {},
                                               'types': {'creased': 'bool',
                                                         'vertexId': 'MUint64'}}],
                          'vertexValence': [{'argInfo': {'vertexId': {'doc': 'The vertex 64-bit id',
                                                                      'type': 'MUint64'}},
                                             'args': [('vertexId',
                                                       'MUint64',
                                                       'in')],
                                             'defaults': {},
                                             'deprecated': False,
                                             'doc': 'Returns 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': {},
                                             'types': {'vertexId': 'MUint64'}}]},
              'pymelEnums': {}},
  'MFnSubdData': {'enums': {},
                  'methods': {'className': [{'argInfo': {},
                                             'args': [],
                                             'defaults': {},
                                             'deprecated': False,
                                             'doc': 'Returns the name of this class.',
                                             'inArgs': [],
                                             'outArgs': [],
                                             'returnInfo': {'doc': 'Name of this class.',
                                                            'qualifiers': ['*'],
                                                            'type': 'char'},
                                             'returnType': 'char',
                                             'static': True,
                                             'typeQualifiers': {},
                                             'types': {}}],
                              'create': [{'argInfo': {},
                                          'args': [],
                                          'defaults': {},
                                          'deprecated': False,
                                          'doc': 'Create 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': {},
                                          'types': {}}],
                              'type': [{'argInfo': {},
                                        'args': [],
                                        'defaults': {},
                                        'deprecated': False,
                                        'doc': 'Function set type',
                                        'inArgs': [],
                                        'outArgs': [],
                                        'returnInfo': {'doc': 'the class type.',
                                                       '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': 'Given a 64-bit name, return the base mesh face.',
                                         'inArgs': ['id'],
                                         'outArgs': [],
                                         'returnInfo': {'doc': '',
                                                        'qualifiers': [],
                                                        'type': 'int'},
                                         'returnType': 'int',
                                         'static': True,
                                         'typeQualifiers': {},
                                         'types': {'id': 'MUint64'}}],
                               'baseFaceId': [{'argInfo': {'id': {'doc': 'The 64-bit name of the component',
                                                                  'type': 'MUint64'}},
                                               'args': [('id',
                                                         'MUint64',
                                                         'in')],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': 'Given 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': {},
                                               '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': 'Given 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': 'This method is obsolete. [as of Maya 2019]',
                                                       'inArgs': ['base'],
                                                       'outArgs': [],
                                                       'returnInfo': {'doc': '',
                                                                      'qualifiers': [],
                                                                      'type': 'MUint64'},
                                                       'returnType': 'MUint64',
                                                       'static': True,
                                                       'typeQualifiers': {},
                                                       'types': {'base': 'long'}}],
                               'baseFaceIndex': [{'argInfo': {'id': {'doc': 'The 64-bit name of the component',
                                                                     'type': 'MUint64'}},
                                                  'args': [('id',
                                                            'MUint64',
                                                            'in')],
                                                  'defaults': {},
                                                  'deprecated': True,
                                                  'doc': 'This method is obsolete. [as of Maya 2019]',
                                                  'inArgs': ['id'],
                                                  'outArgs': [],
                                                  'returnInfo': {'doc': '',
                                                                 'qualifiers': [],
                                                                 'type': 'long'},
                                                  'returnType': 'long',
                                                  'static': True,
                                                  'typeQualifiers': {},
                                                  'types': {'id': 'MUint64'}}],
                               'baseFaceIndexFromId': [{'argInfo': {'id': {'doc': 'The 64-bit name of the component',
                                                                           'type': 'MUint64'}},
                                                        'args': [('id',
                                                                  'MUint64',
                                                                  'in')],
                                                        'defaults': {},
                                                        'deprecated': False,
                                                        'doc': 'Same as base().',
                                                        'inArgs': ['id'],
                                                        'outArgs': [],
                                                        'returnInfo': {'doc': '',
                                                                       'qualifiers': [],
                                                                       'type': 'uint'},
                                                        'returnType': 'uint',
                                                        'static': True,
                                                        'typeQualifiers': {},
                                                        'types': {'id': 'MUint64'}}],
                               'className': [{'argInfo': {},
                                              'args': [],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': 'Returns the name of this class.',
                                              'inArgs': [],
                                              'outArgs': [],
                                              'returnInfo': {'doc': 'The name of this class.',
                                                             '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': "One 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': {},
                                           'types': {'id': 'MUint64'}}],
                               'first': [{'argInfo': {'id': {'doc': 'The 64-bit name of the component',
                                                             'type': 'MUint64'}},
                                          'args': [('id', 'MUint64', 'in')],
                                          'defaults': {},
                                          'deprecated': False,
                                          'doc': 'Given 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': {},
                                          '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': 'Given 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': ['&'],
                                                                   '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': 'Given 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': 'Given a 64-bit name, return the level of the component',
                                          'inArgs': ['id'],
                                          'outArgs': [],
                                          'returnInfo': {'doc': '',
                                                         'qualifiers': [],
                                                         'type': 'int'},
                                          'returnType': 'int',
                                          'static': True,
                                          'typeQualifiers': {},
                                          'types': {'id': 'MUint64'}}],
                               'levelOneFaceAsLong': [{'argInfo': {'id': {'doc': 'The 64-bit name of the component',
                                                                          'type': 'MUint64'}},
                                                       'args': [('id',
                                                                 'MUint64',
                                                                 'in')],
                                                       'defaults': {},
                                                       'deprecated': True,
                                                       'doc': 'This method is obsolete. [as of Maya 2019]',
                                                       'inArgs': ['id'],
                                                       'outArgs': [],
                                                       'returnInfo': {'doc': '',
                                                                      'qualifiers': [],
                                                                      'type': 'long'},
                                                       'returnType': 'long',
                                                       'static': True,
                                                       'typeQualifiers': {},
                                                       'types': {'id': 'MUint64'}}],
                               'levelOneFaceId': [{'argInfo': {'id': {'doc': 'The 64-bit name of the component',
                                                                      'type': 'MUint64'}},
                                                   'args': [('id',
                                                             'MUint64',
                                                             'in')],
                                                   'defaults': {},
                                                   'deprecated': False,
                                                   'doc': 'Given 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': {},
                                                   'types': {'id': 'MUint64'}}],
                               'levelOneFaceIdFromIndex': [{'argInfo': {'index': {'doc': 'The 64-bit name of the component',
                                                                                  'type': 'uint'}},
                                                            'args': [('index',
                                                                      'uint',
                                                                      'in')],
                                                            'defaults': {},
                                                            'deprecated': False,
                                                            'doc': 'Given 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': 'This method is obsolete. [as of Maya 2019]',
                                                           'inArgs': ['one'],
                                                           'outArgs': [],
                                                           'returnInfo': {'doc': '',
                                                                          'qualifiers': [],
                                                                          'type': 'MUint64'},
                                                           'returnType': 'MUint64',
                                                           'static': True,
                                                           'typeQualifiers': {},
                                                           'types': {'one': 'long'}}],
                               'levelOneFaceIndexFromId': [{'argInfo': {'id': {'doc': 'The 64-bit name of the component',
                                                                               'type': 'MUint64'}},
                                                            'args': [('id',
                                                                      'MUint64',
                                                                      'in')],
                                                            'defaults': {},
                                                            'deprecated': False,
                                                            'doc': 'Given 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': 'uint'},
                                                            'returnType': 'uint',
                                                            'static': True,
                                                            'typeQualifiers': {},
                                                            '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': 'Return 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': ['&']},
                                                     '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': 'Return 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': {'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': 'Given 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': {},
                                                 'types': {'id': 'MUint64'}}],
                               'path': [{'argInfo': {'id': {'doc': 'The 64-bit name of the component',
                                                            'type': 'MUint64'}},
                                         'args': [('id', 'MUint64', 'in')],
                                         'defaults': {},
                                         'deprecated': False,
                                         'doc': 'Given 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': {},
                                         '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': 'Compute 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': {'id': ['&']},
                                              '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': 'Given 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',
                                                                                         '&'],
                                                                          'secondIndex': ['unsigned',
                                                                                          '&']},
                                                       'types': {'firstIndex': 'uint',
                                                                 'id': 'MUint64',
                                                                 'secondIndex': 'uint'}}]},
                   'pymelEnums': {}},
  'MFnToggleManip': {'enums': {},
                     'invertibles': [('setDirection', 'direction'),
                                     ('setLength', 'length'),
                                     ('setStartPoint', 'startPoint'),
                                     ('setToggle', 'toggle')],
                     'methods': {'className': [{'argInfo': {},
                                                'args': [],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': 'Returns the name of this class.',
                                                'inArgs': [],
                                                'outArgs': [],
                                                'returnInfo': {'doc': 'Name of this class.',
                                                               'qualifiers': ['*'],
                                                               'type': 'char'},
                                                'returnType': 'char',
                                                'static': True,
                                                'typeQualifiers': {},
                                                'types': {}}],
                                 'connectToTogglePlug': [{'argInfo': {'togglePlug': {'doc': 'the toggle plug',
                                                                                     'type': 'MPlug'}},
                                                          'args': [('togglePlug',
                                                                    'MPlug',
                                                                    'in')],
                                                          'defaults': {},
                                                          'deprecated': False,
                                                          'doc': 'Connect 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': "Creates 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': {},
                                             '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': "Creates 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': {'manipName': ['const',
                                                                              '&'],
                                                                'toggleName': ['const',
                                                                               '&']},
                                             'types': {'manipName': 'MString',
                                                       'toggleName': 'MString'}}],
                                 'direction': [{'argInfo': {},
                                                'args': [],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': 'Returns the direction.',
                                                'inArgs': [],
                                                'inverse': ('setDirection',
                                                            False),
                                                'outArgs': [],
                                                'returnInfo': {'doc': 'The direction',
                                                               'qualifiers': [],
                                                               'type': 'MVector'},
                                                'returnType': 'MVector',
                                                'static': False,
                                                'typeQualifiers': {},
                                                'types': {}}],
                                 'directionIndex': [{'argInfo': {},
                                                     'args': [],
                                                     'defaults': {},
                                                     'deprecated': False,
                                                     'doc': 'Returns the index of the direction. The data type corresponding to this index is MFnNumericData::k3Double.',
                                                     'inArgs': [],
                                                     'outArgs': [],
                                                     'returnInfo': {'doc': 'Direction index',
                                                                    'qualifiers': [],
                                                                    'type': 'uint'},
                                                     'returnType': 'uint',
                                                     'static': False,
                                                     'typeQualifiers': {},
                                                     'types': {}}],
                                 'length': [{'argInfo': {},
                                             'args': [],
                                             'defaults': {},
                                             'deprecated': False,
                                             'doc': 'Returns the length.',
                                             'inArgs': [],
                                             'inverse': ('setLength', False),
                                             'outArgs': [],
                                             'returnInfo': {'doc': 'Length',
                                                            'qualifiers': [],
                                                            'type': 'double'},
                                             'returnType': 'double',
                                             'static': False,
                                             'typeQualifiers': {},
                                             'types': {}}],
                                 'lengthIndex': [{'argInfo': {},
                                                  'args': [],
                                                  'defaults': {},
                                                  'deprecated': False,
                                                  'doc': 'Returns 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': 'uint'},
                                                  'returnType': 'uint',
                                                  'static': False,
                                                  'typeQualifiers': {},
                                                  'types': {}}],
                                 'setDirection': [{'argInfo': {'direction': {'doc': 'the direction of the ToggleManip',
                                                                             'type': 'MVector'}},
                                                   'args': [('direction',
                                                             'MVector',
                                                             'in')],
                                                   'defaults': {},
                                                   'deprecated': False,
                                                   'doc': 'Sets 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': 'Sets the length of the ToggleManip.',
                                                'inArgs': ['length'],
                                                'inverse': ('length', True),
                                                'outArgs': [],
                                                'returnInfo': {'doc': '',
                                                               'qualifiers': [],
                                                               'type': None},
                                                'returnType': None,
                                                'static': False,
                                                'typeQualifiers': {},
                                                'types': {'length': 'double'}}],
                                 'setStartPoint': [{'argInfo': {'startPoint': {'doc': 'the start point of the ToggleManip',
                                                                               'type': 'MPoint'}},
                                                    'args': [('startPoint',
                                                              'MPoint',
                                                              'in')],
                                                    'defaults': {},
                                                    'deprecated': False,
                                                    'doc': 'Sets 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': 'Sets the toggle of the ToggleManip.',
                                                'inArgs': ['toggle'],
                                                'inverse': ('toggle', True),
                                                'outArgs': [],
                                                'returnInfo': {'doc': '',
                                                               'qualifiers': [],
                                                               'type': None},
                                                'returnType': None,
                                                'static': False,
                                                'typeQualifiers': {},
                                                'types': {'toggle': 'bool'}}],
                                 'startPoint': [{'argInfo': {},
                                                 'args': [],
                                                 'defaults': {},
                                                 'deprecated': False,
                                                 'doc': 'Returns the start point.',
                                                 'inArgs': [],
                                                 'inverse': ('setStartPoint',
                                                             False),
                                                 'outArgs': [],
                                                 'returnInfo': {'doc': 'The start point',
                                                                'qualifiers': [],
                                                                'type': 'MPoint'},
                                                 'returnType': 'MPoint',
                                                 'static': False,
                                                 'typeQualifiers': {},
                                                 'types': {}}],
                                 'startPointIndex': [{'argInfo': {},
                                                      'args': [],
                                                      'defaults': {},
                                                      'deprecated': False,
                                                      'doc': 'Returns 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': 'uint'},
                                                      'returnType': 'uint',
                                                      'static': False,
                                                      'typeQualifiers': {},
                                                      'types': {}}],
                                 'toggle': [{'argInfo': {},
                                             'args': [],
                                             'defaults': {},
                                             'deprecated': False,
                                             'doc': 'Returns the toggle.',
                                             'inArgs': [],
                                             'inverse': ('setToggle', False),
                                             'outArgs': [],
                                             'returnInfo': {'doc': 'Toggle',
                                                            'qualifiers': [],
                                                            'type': 'bool'},
                                             'returnType': 'bool',
                                             'static': False,
                                             'typeQualifiers': {},
                                             'types': {}}],
                                 'toggleIndex': [{'argInfo': {},
                                                  'args': [],
                                                  'defaults': {},
                                                  'deprecated': False,
                                                  'doc': 'Returns 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': 'uint'},
                                                  'returnType': 'uint',
                                                  'static': False,
                                                  'typeQualifiers': {},
                                                  'types': {}}],
                                 'type': [{'argInfo': {},
                                           'args': [],
                                           'defaults': {},
                                           'deprecated': False,
                                           'doc': 'Function set type',
                                           'inArgs': [],
                                           'outArgs': [],
                                           'returnInfo': {'doc': 'the class type.',
                                                          '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': 'Returns the name of this class.',
                                                'inArgs': [],
                                                'outArgs': [],
                                                'returnInfo': {'doc': 'Name of this class.',
                                                               'qualifiers': ['*'],
                                                               'type': 'char'},
                                                'returnType': 'char',
                                                'static': True,
                                                'typeQualifiers': {},
                                                'types': {}}],
                                 'name': [{'argInfo': {},
                                           'args': [],
                                           'defaults': {},
                                           'deprecated': False,
                                           'doc': "Returns the tool context's name.",
                                           'inArgs': [],
                                           'outArgs': [],
                                           'returnInfo': {'doc': 'Name string',
                                                          'qualifiers': [],
                                                          'type': 'MString'},
                                           'returnType': 'MString',
                                           'static': False,
                                           'typeQualifiers': {},
                                           'types': {}}],
                                 'title': [{'argInfo': {},
                                            'args': [],
                                            'defaults': {},
                                            'deprecated': False,
                                            'doc': "Returns the tool context's title.",
                                            'inArgs': [],
                                            'outArgs': [],
                                            'returnInfo': {'doc': 'Title string',
                                                           'qualifiers': [],
                                                           'type': 'MString'},
                                            'returnType': 'MString',
                                            'static': False,
                                            'typeQualifiers': {},
                                            'types': {}}],
                                 'type': [{'argInfo': {},
                                           'args': [],
                                           'defaults': {},
                                           'deprecated': False,
                                           'doc': 'Function set type',
                                           'inArgs': [],
                                           'outArgs': [],
                                           'returnInfo': {'doc': 'the class type.',
                                                          'qualifiers': [],
                                                          'type': ('MFn',
                                                                   'Type')},
                                           'returnType': ('MFn', 'Type'),
                                           'static': False,
                                           'typeQualifiers': {},
                                           'types': {}}]},
                     'pymelEnums': {}},
  'MFnTransform': {'enums': {'LimitType': {'valueDocs': {},
                                           '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': 'Returns the name of this class.',
                                              'inArgs': [],
                                              'outArgs': [],
                                              'returnInfo': {'doc': 'Name of this class.',
                                                             'qualifiers': ['*'],
                                                             'type': 'char'},
                                              'returnType': 'char',
                                              'static': True,
                                              'typeQualifiers': {},
                                              'types': {}}],
                               'clearRestPosition': [{'argInfo': {},
                                                      'args': [],
                                                      'defaults': {},
                                                      'deprecated': False,
                                                      'doc': 'Clear 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': 'Creates 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': {},
                                           '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': 'Enable 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': {},
                                                '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': 'Retrieve 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': ['&']},
                                                'types': {'quaternion': 'MQuaternion',
                                                          'space': ('MSpace',
                                                                    'Space')}},
                                               {'argInfo': {'rotation': {'doc': 'the euler rotation in radians',
                                                                         'type': 'MEulerRotation'}},
                                                'args': [('rotation',
                                                          'MEulerRotation',
                                                          'out')],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': 'Retrieve 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': 'angular'}},
                                                'args': [('rotation',
                                                          'double__array3',
                                                          'out'),
                                                         ('order',
                                                          ('MTransformationMatrix',
                                                           'RotationOrder'),
                                                          'out')],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': 'Retrieve 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': ['&']},
                                                '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': 'This method is obsolete. [as of Maya 85]',
                                                'inArgs': ['space'],
                                                'inverse': ('setRotation',
                                                            False),
                                                'outArgs': ['rotation',
                                                            'order'],
                                                'returnInfo': {'doc': '',
                                                               'qualifiers': [],
                                                               'type': None},
                                                'returnType': None,
                                                'static': False,
                                                'typeQualifiers': {'order': ['&']},
                                                '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': 'Retrieve 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': {'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': 'Retrieve the scaling component of this transformation.',
                                             'inArgs': [],
                                             'inverse': ('setScale', False),
                                             'outArgs': ['scale'],
                                             'returnInfo': {'doc': '',
                                                            'qualifiers': [],
                                                            'type': None},
                                             'returnType': None,
                                             'static': False,
                                             'typeQualifiers': {},
                                             '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': 'Retrieve the shearing component of this transformation.',
                                             'inArgs': [],
                                             'inverse': ('setShear', False),
                                             'outArgs': ['shear'],
                                             'returnInfo': {'doc': '',
                                                            'qualifiers': [],
                                                            'type': None},
                                             'returnType': None,
                                             'static': False,
                                             'typeQualifiers': {},
                                             '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': 'Retrieve the translation component of this transformation in centimeters.',
                                                   'inArgs': ['space'],
                                                   'outArgs': [],
                                                   'returnInfo': {'doc': 'Translation vector in centimeters',
                                                                  'qualifiers': [],
                                                                  'type': 'MVector',
                                                                  'unitType': 'linear'},
                                                   'returnType': 'MVector',
                                                   'static': False,
                                                   'typeQualifiers': {},
                                                   'types': {'space': ('MSpace',
                                                                       'Space')}}],
                               'isLimited': [{'argInfo': {'type': {'doc': 'type to query limit',
                                                                   'type': ('MFnTransform',
                                                                            'LimitType')}},
                                              'args': [('type',
                                                        ('MFnTransform',
                                                         'LimitType'),
                                                        'in')],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': 'Determine 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': {},
                                              'types': {'type': ('MFnTransform',
                                                                 'LimitType')}}],
                               'limitValue': [{'argInfo': {'type': {'doc': 'type to query limit',
                                                                    'type': ('MFnTransform',
                                                                             'LimitType')}},
                                               'args': [('type',
                                                         ('MFnTransform',
                                                          'LimitType'),
                                                         'in')],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': 'Determine 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': {},
                                               'types': {'type': ('MFnTransform',
                                                                  'LimitType')}}],
                               'resetFromRestPosition': [{'argInfo': {},
                                                          'args': [],
                                                          'defaults': {},
                                                          'deprecated': False,
                                                          'doc': 'Reset 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': 'Retrieve 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': {},
                                                 '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': 'Relatively 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',
                                                                               '&']},
                                             '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': 'Relatively change the rotation component of this transformation.',
                                             'inArgs': ['rotation', 'space'],
                                             'outArgs': [],
                                             'returnInfo': {'doc': '',
                                                            'qualifiers': [],
                                                            'type': None},
                                             'returnType': None,
                                             'static': False,
                                             'typeQualifiers': {'rotation': ['const',
                                                                             '&']},
                                             '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': 'Relatively change the rotation component of this transformation.',
                                             'inArgs': ['rotation',
                                                        'order',
                                                        'space'],
                                             'outArgs': [],
                                             'returnInfo': {'doc': '',
                                                            'qualifiers': [],
                                                            'type': None},
                                             'returnType': None,
                                             'static': False,
                                             'typeQualifiers': {'rotation': ['const']},
                                             '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': 'Relatively 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': {},
                                                       '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': 'Returns 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': {},
                                                      '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': 'Returns 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': {},
                                                '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': 'Return 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': 'linear'},
                                                           'returnType': 'MVector',
                                                           'static': False,
                                                           'typeQualifiers': {},
                                                           'types': {'space': ('MSpace',
                                                                               'Space')}}],
                               'rotationOrder': [{'argInfo': {},
                                                  'args': [],
                                                  'defaults': {},
                                                  'deprecated': False,
                                                  'doc': 'Returns 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': {},
                                                  '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': 'Relatively 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': 'Returns 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': {},
                                               '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': 'Returns 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': 'linear'},
                                                          'returnType': 'MVector',
                                                          'static': False,
                                                          'typeQualifiers': {},
                                                          'types': {'space': ('MSpace',
                                                                              'Space')}}],
                               'set': [{'argInfo': {'transform': {'doc': 'the matrix to copy',
                                                                  'type': 'MTransformationMatrix'}},
                                        'args': [('transform',
                                                  'MTransformationMatrix',
                                                  'in')],
                                        'defaults': {},
                                        'deprecated': False,
                                        'doc': 'Change 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': 'linear'}},
                                             'args': [('type',
                                                       ('MFnTransform',
                                                        'LimitType'),
                                                       'in'),
                                                      ('value',
                                                       'double',
                                                       'in')],
                                             'defaults': {},
                                             'deprecated': False,
                                             'doc': 'Change 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': {},
                                             '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': 'Change 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': 'Set 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': {'quat': ['const',
                                                                                     '&']},
                                                         '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': 'Set 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': {'point': ['const',
                                                                                '&']},
                                                   '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': 'linear'}},
                                                              'args': [('vector',
                                                                        'MVector',
                                                                        'in'),
                                                                       ('space',
                                                                        ('MSpace',
                                                                         'Space'),
                                                                        'in')],
                                                              'defaults': {},
                                                              'deprecated': False,
                                                              'doc': 'Set 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': {'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': 'Change 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',
                                                                                  '&']},
                                                'types': {'quaternion': 'MQuaternion',
                                                          'space': ('MSpace',
                                                                    'Space')}},
                                               {'argInfo': {'rotation': {'doc': 'the euler rotation',
                                                                         'type': 'MEulerRotation'}},
                                                'args': [('rotation',
                                                          'MEulerRotation',
                                                          'in')],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': 'Change 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': 'angular'}},
                                                'args': [('rotation',
                                                          'double__array3',
                                                          'in'),
                                                         ('order',
                                                          ('MTransformationMatrix',
                                                           'RotationOrder'),
                                                          'in')],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': 'Change 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': {'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': 'This method is obsolete. [as of Maya 85]',
                                                'inArgs': ['rotation',
                                                           'order',
                                                           'space'],
                                                'inverse': ('getRotation',
                                                            True),
                                                'outArgs': [],
                                                'returnInfo': {'doc': '',
                                                               'qualifiers': [],
                                                               'type': None},
                                                'returnType': None,
                                                'static': False,
                                                'typeQualifiers': {'rotation': ['const']},
                                                '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': 'Change 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': {},
                                                     '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': 'Change 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': {},
                                                          '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': 'Set 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': 'Set 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': {'point': ['const',
                                                                               '&']},
                                                  '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': 'linear'}},
                                                             'args': [('vector',
                                                                       'MVector',
                                                                       'in'),
                                                                      ('space',
                                                                       ('MSpace',
                                                                        'Space'),
                                                                       'in')],
                                                             'defaults': {},
                                                             'deprecated': False,
                                                             'doc': 'Set 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': {'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': 'Set 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': 'linear'}},
                                                   'args': [('vector',
                                                             'MVector',
                                                             'in'),
                                                            ('space',
                                                             ('MSpace',
                                                              'Space'),
                                                             'in')],
                                                   'defaults': {},
                                                   'deprecated': False,
                                                   'doc': 'Change the translation component of this transformation.',
                                                   'inArgs': ['vector',
                                                              'space'],
                                                   'inverse': ('translation',
                                                               True),
                                                   'outArgs': [],
                                                   'returnInfo': {'doc': '',
                                                                  'qualifiers': [],
                                                                  'type': None},
                                                   'returnType': None,
                                                   'static': False,
                                                   'typeQualifiers': {'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': 'Relatively 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': 'Retrieve 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': {},
                                                   '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': 'linear'}},
                                                'args': [('vector',
                                                          'MVector',
                                                          'in'),
                                                         ('space',
                                                          ('MSpace', 'Space'),
                                                          'in')],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': 'Relatively change the translation component of this transformation.',
                                                'inArgs': ['vector', 'space'],
                                                'outArgs': [],
                                                'returnInfo': {'doc': '',
                                                               'qualifiers': [],
                                                               'type': None},
                                                'returnType': None,
                                                'static': False,
                                                'typeQualifiers': {'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': 'This method is obsolete. [as of Maya 85]',
                                                'inArgs': ['space'],
                                                'inverse': ('setTranslation',
                                                            False),
                                                'outArgs': [],
                                                'returnInfo': {'doc': 'Translation vector in centimeters',
                                                               'qualifiers': [],
                                                               'type': 'MVector'},
                                                'returnType': 'MVector',
                                                'static': False,
                                                'typeQualifiers': {},
                                                'types': {'space': ('MSpace',
                                                                    'Space')}}],
                               'type': [{'argInfo': {},
                                         'args': [],
                                         'defaults': {},
                                         'deprecated': False,
                                         'doc': 'Function set type',
                                         'inArgs': [],
                                         'outArgs': [],
                                         'returnInfo': {'doc': 'the class type.',
                                                        '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': 'Add the specified element to the component.',
                                                            'inArgs': ['sIndex',
                                                                       'tIndex',
                                                                       'uIndex'],
                                                            'outArgs': [],
                                                            'returnInfo': {'doc': '',
                                                                           'qualifiers': [],
                                                                           'type': None},
                                                            'returnType': None,
                                                            'static': False,
                                                            'typeQualifiers': {},
                                                            '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': 'Add 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': 'Returns the name of this class.',
                                                           'inArgs': [],
                                                           'outArgs': [],
                                                           'returnInfo': {'doc': 'Name of this class.',
                                                                          'qualifiers': ['*'],
                                                                          'type': 'char'},
                                                           'returnType': 'char',
                                                           'static': True,
                                                           'typeQualifiers': {},
                                                           'types': {}}],
                                            'create': [{'argInfo': {'compType': {'doc': 'the type of component to create',
                                                                                 'type': ('MFn',
                                                                                          'Type')}},
                                                        'args': [('compType',
                                                                  ('MFn',
                                                                   'Type'),
                                                                  'in')],
                                                        'defaults': {},
                                                        'deprecated': False,
                                                        'doc': 'Create 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': {},
                                                        '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': 'Returns 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': 'Get the specified element from the component.',
                                                            'inArgs': ['index'],
                                                            'outArgs': ['sIndex',
                                                                        'tIndex',
                                                                        'uIndex'],
                                                            'returnInfo': {'doc': '',
                                                                           'qualifiers': [],
                                                                           'type': None},
                                                            'returnType': None,
                                                            'static': False,
                                                            'typeQualifiers': {'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': 'Get 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': 'Marks 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': {},
                                                                 'types': {'maxS': 'int',
                                                                           'maxT': 'int',
                                                                           'maxU': 'int'}}],
                                            'type': [{'argInfo': {},
                                                      'args': [],
                                                      'defaults': {},
                                                      'deprecated': False,
                                                      'doc': 'Function set type',
                                                      'inArgs': [],
                                                      'outArgs': [],
                                                      'returnInfo': {'doc': 'the class type.',
                                                                     'qualifiers': [],
                                                                     'type': ('MFn',
                                                                              'Type')},
                                                      'returnType': ('MFn',
                                                                     'Type'),
                                                      'static': False,
                                                      'typeQualifiers': {},
                                                      'types': {}}]},
                                'pymelEnums': {}},
  'MFnTurbulenceField': {'enums': {},
                         'invertibles': [('setFrequency', 'frequency'),
                                         ('setPhase', 'phase')],
                         'methods': {'className': [{'argInfo': {},
                                                    'args': [],
                                                    'defaults': {},
                                                    'deprecated': False,
                                                    'doc': 'Returns the name of this class.',
                                                    'inArgs': [],
                                                    'outArgs': [],
                                                    'returnInfo': {'doc': 'Name of this class.',
                                                                   'qualifiers': ['*'],
                                                                   'type': 'char'},
                                                    'returnType': 'char',
                                                    'static': True,
                                                    'typeQualifiers': {},
                                                    'types': {}}],
                                     'frequency': [{'argInfo': {},
                                                    'args': [],
                                                    'defaults': {},
                                                    'deprecated': False,
                                                    'doc': 'Returns 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': {},
                                                    'types': {}}],
                                     'phase': [{'argInfo': {},
                                                'args': [],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': 'Returns 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': {},
                                                'types': {}}],
                                     'setFrequency': [{'argInfo': {'value': {'doc': 'A value representing a noise generation parameter.',
                                                                             'type': 'double'}},
                                                       'args': [('value',
                                                                 'double',
                                                                 'in')],
                                                       'defaults': {},
                                                       'deprecated': False,
                                                       'doc': 'Sets 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': {},
                                                       'types': {'value': 'double'}}],
                                     'setPhase': [{'argInfo': {'value': {'doc': 'A value representing a noise generation parameter.',
                                                                         'type': 'double'}},
                                                   'args': [('value',
                                                             'double',
                                                             'in')],
                                                   'defaults': {},
                                                   'deprecated': False,
                                                   'doc': 'Sets 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': {},
                                                   'types': {'value': 'double'}}],
                                     'type': [{'argInfo': {},
                                               'args': [],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': 'Function set type',
                                               'inArgs': [],
                                               'outArgs': [],
                                               'returnInfo': {'doc': 'the class type.',
                                                              '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': 'Return 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': {},
                                                  'types': {}}],
                                    'className': [{'argInfo': {},
                                                   'args': [],
                                                   'defaults': {},
                                                   'deprecated': False,
                                                   'doc': 'Returns the name of this class.',
                                                   'inArgs': [],
                                                   'outArgs': [],
                                                   'returnInfo': {'doc': 'Name of this class.',
                                                                  'qualifiers': ['*'],
                                                                  'type': 'char'},
                                                   'returnType': 'char',
                                                   'static': True,
                                                   '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': 'Create 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': {'brief': ['const',
                                                                             '&'],
                                                                   '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': 'Create 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': {'brief': ['const',
                                                                             '&'],
                                                                   'full': ['const',
                                                                            '&']},
                                                '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': 'Get 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': 'Set 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': 'Function set type',
                                              'inArgs': [],
                                              'outArgs': [],
                                              'returnInfo': {'doc': 'the class type.',
                                                             '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': 'Extract 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': 'Return 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': {},
                                                'types': {}}],
                                     'className': [{'argInfo': {},
                                                    'args': [],
                                                    'defaults': {},
                                                    'deprecated': False,
                                                    'doc': 'Returns the name of this class.',
                                                    'inArgs': [],
                                                    'outArgs': [],
                                                    'returnInfo': {'doc': 'Name of this class.',
                                                                   'qualifiers': ['*'],
                                                                   'type': 'char'},
                                                    'returnType': 'char',
                                                    'static': True,
                                                    'typeQualifiers': {},
                                                    'types': {}}],
                                     'copyTo': [{'argInfo': {'dest': {'doc': 'the MUint64Array to populate',
                                                                      'type': 'MUint64Array'}},
                                                 'args': [('dest',
                                                           'MUint64Array',
                                                           'out')],
                                                 'defaults': {},
                                                 'deprecated': False,
                                                 'doc': 'Copy 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': 'Create 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': {},
                                                 'types': {}},
                                                {'argInfo': {'arr': {'doc': 'the data to use when initializing this instance',
                                                                     'type': 'MUint64Array'}},
                                                 'args': [('arr',
                                                           'MUint64Array',
                                                           'in')],
                                                 'defaults': {},
                                                 'deprecated': False,
                                                 'doc': 'Create 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': {'arr': ['const',
                                                                            '&']},
                                                 'types': {'arr': 'MUint64Array'}}],
                                     'length': [{'argInfo': {},
                                                 'args': [],
                                                 'defaults': {},
                                                 'deprecated': False,
                                                 'doc': 'Return the number of MUint64s in the instance.',
                                                 'inArgs': [],
                                                 'outArgs': [],
                                                 'returnInfo': {'doc': 'The number of MUint64s in the instance',
                                                                'qualifiers': [],
                                                                'type': 'uint'},
                                                 'returnType': 'uint',
                                                 'static': False,
                                                 'typeQualifiers': {},
                                                 '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': 'Set the element at the specified index of the array.',
                                              'inArgs': ['element', 'index'],
                                              'outArgs': [],
                                              'returnInfo': {'doc': '',
                                                             'qualifiers': [],
                                                             'type': None},
                                              'returnType': None,
                                              'static': False,
                                              'typeQualifiers': {'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': 'Set 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': 'Function set type',
                                               'inArgs': [],
                                               'outArgs': [],
                                               'returnInfo': {'doc': 'the class type.',
                                                              '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': 'Add the specified element to the component.',
                                                                  'inArgs': ['element'],
                                                                  'outArgs': [],
                                                                  'returnInfo': {'doc': '',
                                                                                 'qualifiers': [],
                                                                                 'type': None},
                                                                  'returnType': None,
                                                                  'static': False,
                                                                  'typeQualifiers': {},
                                                                  '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': 'Add 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': 'Returns the name of this class.',
                                                                 'inArgs': [],
                                                                 'outArgs': [],
                                                                 'returnInfo': {'doc': 'Name of this class.',
                                                                                'qualifiers': ['*'],
                                                                                'type': 'char'},
                                                                 'returnType': 'char',
                                                                 'static': True,
                                                                 'typeQualifiers': {},
                                                                 'types': {}}],
                                                  'create': [{'argInfo': {'compType': {'doc': 'the type of component to create',
                                                                                       'type': ('MFn',
                                                                                                'Type')}},
                                                              'args': [('compType',
                                                                        ('MFn',
                                                                         'Type'),
                                                                        'in')],
                                                              'defaults': {},
                                                              'deprecated': False,
                                                              'doc': 'Create 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': {},
                                                              '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': 'Returns 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': {},
                                                               'types': {'index': 'int'}}],
                                                  'getCompleteData': [{'argInfo': {'numElements': {'doc': 'storage for the maximum number of elements',
                                                                                                   'type': 'MUint64'}},
                                                                       'args': [('numElements',
                                                                                 'MUint64',
                                                                                 'out')],
                                                                       'defaults': {},
                                                                       'deprecated': False,
                                                                       'doc': 'Returns 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': 'Get 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': 'Marks 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': {},
                                                                       'types': {'numElements': 'MUint64'}}],
                                                  'type': [{'argInfo': {},
                                                            'args': [],
                                                            'defaults': {},
                                                            'deprecated': False,
                                                            'doc': 'Function set type',
                                                            'inArgs': [],
                                                            'outArgs': [],
                                                            'returnInfo': {'doc': 'the class type.',
                                                                           'qualifiers': [],
                                                                           'type': ('MFn',
                                                                                    'Type')},
                                                            'returnType': ('MFn',
                                                                           'Type'),
                                                            'static': False,
                                                            'typeQualifiers': {},
                                                            'types': {}}]},
                                      'pymelEnums': {}},
  'MFnUniformField': {'enums': {},
                      'invertibles': [('setDirection', 'direction')],
                      'methods': {'className': [{'argInfo': {},
                                                 'args': [],
                                                 'defaults': {},
                                                 'deprecated': False,
                                                 'doc': 'Returns the name of this class.',
                                                 'inArgs': [],
                                                 'outArgs': [],
                                                 'returnInfo': {'doc': 'Name of this class.',
                                                                'qualifiers': ['*'],
                                                                'type': 'char'},
                                                 'returnType': 'char',
                                                 'static': True,
                                                 'typeQualifiers': {},
                                                 'types': {}}],
                                  'direction': [{'argInfo': {},
                                                 'args': [],
                                                 'defaults': {},
                                                 'deprecated': False,
                                                 'doc': 'Returns 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': {},
                                                 'types': {}}],
                                  'setDirection': [{'argInfo': {'uniformDirection': {'doc': 'A vector representing direction.',
                                                                                     'type': 'MVector'}},
                                                    'args': [('uniformDirection',
                                                              'MVector',
                                                              'in')],
                                                    'defaults': {},
                                                    'deprecated': False,
                                                    'doc': 'Sets 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': 'Function set type',
                                            'inArgs': [],
                                            'outArgs': [],
                                            'returnInfo': {'doc': 'the class type.',
                                                           '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': [('setDefault', 'getDefault'),
                                       ('setMax', 'getMax'),
                                       ('setMin', 'getMin'),
                                       ('setSoftMax', 'getSoftMax'),
                                       ('setSoftMin', 'getSoftMin')],
                       'methods': {'className': [{'argInfo': {},
                                                  'args': [],
                                                  'defaults': {},
                                                  'deprecated': False,
                                                  'doc': 'Returns the name of this class.',
                                                  'inArgs': [],
                                                  'outArgs': [],
                                                  'returnInfo': {'doc': 'Name of this class.',
                                                                 'qualifiers': ['*'],
                                                                 'type': 'char'},
                                                  'returnType': 'char',
                                                  'static': True,
                                                  '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': 'Create 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': {'brief': ['const',
                                                                            '&'],
                                                                  'full': ['const',
                                                                           '&']},
                                               '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': 'Create 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': {'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': 'Create 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': {'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': 'Create 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': {'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': 'Gets 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': 'Gets 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': 'Gets 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': 'Gets 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': 'Return 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': 'Return 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': 'Return 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': 'Return 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': 'Return 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': 'Return 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': 'Return 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': 'Return 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': 'Return 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': 'Return 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': 'Return 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': 'Return 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': 'Return 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': 'Return 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': 'Return 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': 'Return 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': 'Determine 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': {},
                                               'types': {}}],
                                   'hasMin': [{'argInfo': {},
                                               'args': [],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': 'Determine 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': {},
                                               'types': {}}],
                                   'hasSoftMax': [{'argInfo': {},
                                                   'args': [],
                                                   'defaults': {},
                                                   'deprecated': False,
                                                   'doc': 'Determine 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': {},
                                                   'types': {}}],
                                   'hasSoftMin': [{'argInfo': {},
                                                   'args': [],
                                                   'defaults': {},
                                                   'deprecated': False,
                                                   'doc': 'Determine 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': {},
                                                   'types': {}}],
                                   'setDefault': [{'argInfo': {'defaultValue': {'doc': 'the new default value for this attribute',
                                                                                'type': 'double'}},
                                                   'args': [('defaultValue',
                                                             'double',
                                                             'in')],
                                                   'defaults': {},
                                                   'deprecated': False,
                                                   'doc': 'Set 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': {},
                                                   'types': {'defaultValue': 'double'}},
                                                  {'argInfo': {'defaultValue': {'doc': 'the new default value for this attribute',
                                                                                'type': 'MTime'}},
                                                   'args': [('defaultValue',
                                                             'MTime',
                                                             'in')],
                                                   'defaults': {},
                                                   'deprecated': False,
                                                   'doc': 'Set 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': 'Set 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': 'Set 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': 'Set 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': {},
                                               'types': {'maxValue': 'double'}},
                                              {'argInfo': {'maxValue': {'doc': 'the new maximum value for this attribute',
                                                                        'type': 'MTime'}},
                                               'args': [('maxValue',
                                                         'MTime',
                                                         'in')],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': 'Set 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': 'Set 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': 'Set 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': 'Set 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': {},
                                               'types': {'minValue': 'double'}},
                                              {'argInfo': {'minValue': {'doc': 'the new minimum value for this attribute',
                                                                        'type': 'MTime'}},
                                               'args': [('minValue',
                                                         'MTime',
                                                         'in')],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': 'Set 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': 'Set 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': 'Set 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': 'Set 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': {},
                                                   'types': {'maxValue': 'double'}},
                                                  {'argInfo': {'maxValue': {'doc': 'the new soft maximum value for this attribute',
                                                                            'type': 'MTime'}},
                                                   'args': [('maxValue',
                                                             'MTime',
                                                             'in')],
                                                   'defaults': {},
                                                   'deprecated': False,
                                                   'doc': 'Set 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': 'Set 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': 'Set 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': 'Set 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': {},
                                                   'types': {'minValue': 'double'}},
                                                  {'argInfo': {'minValue': {'doc': 'the new soft minimum value for this attribute',
                                                                            'type': 'MTime'}},
                                                   'args': [('minValue',
                                                             'MTime',
                                                             'in')],
                                                   'defaults': {},
                                                   'deprecated': False,
                                                   'doc': 'Set 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': 'Set 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': 'Set 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': 'Function set type',
                                             'inArgs': [],
                                             'outArgs': [],
                                             'returnInfo': {'doc': 'the class type.',
                                                            'qualifiers': [],
                                                            'type': ('MFn',
                                                                     'Type')},
                                             'returnType': ('MFn', 'Type'),
                                             'static': False,
                                             'typeQualifiers': {},
                                             'types': {}}],
                                   'unitType': [{'argInfo': {},
                                                 'args': [],
                                                 'defaults': {},
                                                 'deprecated': False,
                                                 'doc': 'Return 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': {},
                                                 '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': {'array': [{'argInfo': {},
                                                'args': [],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': 'Return 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': {},
                                                'types': {}}],
                                     'className': [{'argInfo': {},
                                                    'args': [],
                                                    'defaults': {},
                                                    'deprecated': False,
                                                    'doc': 'Returns the name of this class.',
                                                    'inArgs': [],
                                                    'outArgs': [],
                                                    'returnInfo': {'doc': 'Name of this class.',
                                                                   'qualifiers': ['*'],
                                                                   'type': 'char'},
                                                    'returnType': 'char',
                                                    'static': True,
                                                    'typeQualifiers': {},
                                                    'types': {}}],
                                     'copyTo': [{'argInfo': {'dest': {'doc': 'the MVectorArray to populate',
                                                                      'type': 'MVectorArray'}},
                                                 'args': [('dest',
                                                           'MVectorArray',
                                                           'out')],
                                                 'defaults': {},
                                                 'deprecated': False,
                                                 'doc': 'Copy 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': 'Create 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': {},
                                                 'types': {}},
                                                {'argInfo': {'arr': {'doc': 'the data to use when initializing this instance',
                                                                     'type': 'MVectorArray'}},
                                                 'args': [('arr',
                                                           'MVectorArray',
                                                           'in')],
                                                 'defaults': {},
                                                 'deprecated': False,
                                                 'doc': 'Create 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': {'arr': ['const',
                                                                            '&']},
                                                 'types': {'arr': 'MVectorArray'}}],
                                     'length': [{'argInfo': {},
                                                 'args': [],
                                                 'defaults': {},
                                                 'deprecated': False,
                                                 'doc': 'Return the number of vectors in the instance.',
                                                 'inArgs': [],
                                                 'outArgs': [],
                                                 'returnInfo': {'doc': 'The number of vectors in the instance',
                                                                'qualifiers': [],
                                                                'type': 'uint'},
                                                 'returnType': 'uint',
                                                 'static': False,
                                                 'typeQualifiers': {},
                                                 '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': 'Set 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': 'Set 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': 'Function set type',
                                               'inArgs': [],
                                               'outArgs': [],
                                               'returnInfo': {'doc': 'the class type.',
                                                              'qualifiers': [],
                                                              'type': ('MFn',
                                                                       'Type')},
                                               'returnType': ('MFn', 'Type'),
                                               'static': False,
                                               'typeQualifiers': {},
                                               'types': {}}]},
                         'pymelEnums': {}},
  'MFnVolumeAxisField': {'enums': {},
                         'invertibles': [('setDirection', 'direction'),
                                         ('setDirectionalSpeed',
                                          'directionalSpeed'),
                                         ('setInvertAttenuation',
                                          'invertAttenuation'),
                                         ('setSpeedAlongAxis',
                                          'speedAlongAxis'),
                                         ('setSpeedAroundAxis',
                                          'speedAroundAxis'),
                                         ('setSpeedAwayFromAxis',
                                          'speedAwayFromAxis'),
                                         ('setSpeedAwayFromCenter',
                                          'speedAwayFromCenter'),
                                         ('setTurbulence', 'turbulence'),
                                         ('setTurbulenceFrequency',
                                          'turbulenceFrequency'),
                                         ('setTurbulenceOffset',
                                          'turbulenceOffset'),
                                         ('setTurbulenceSpeed',
                                          'turbulenceSpeed')],
                         'methods': {'className': [{'argInfo': {},
                                                    'args': [],
                                                    'defaults': {},
                                                    'deprecated': False,
                                                    'doc': 'Returns the name of this class.',
                                                    'inArgs': [],
                                                    'outArgs': [],
                                                    'returnInfo': {'doc': 'Name of this class.',
                                                                   'qualifiers': ['*'],
                                                                   'type': 'char'},
                                                    'returnType': 'char',
                                                    'static': True,
                                                    'typeQualifiers': {},
                                                    'types': {}}],
                                     'detailTurbulence': [{'argInfo': {},
                                                           'args': [],
                                                           'defaults': {},
                                                           'deprecated': False,
                                                           'doc': 'Returns 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': {},
                                                           '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': 'Sets the detailTurbulence attribute for the field force.',
                                                           'inArgs': ['value'],
                                                           'outArgs': [],
                                                           'returnInfo': {'doc': '',
                                                                          'qualifiers': [],
                                                                          'type': None},
                                                           'returnType': None,
                                                           'static': False,
                                                           'typeQualifiers': {},
                                                           'types': {'value': 'double'}}],
                                     'direction': [{'argInfo': {},
                                                    'args': [],
                                                    'defaults': {},
                                                    'deprecated': False,
                                                    'doc': 'Returns 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': {},
                                                    'types': {}}],
                                     'directionalSpeed': [{'argInfo': {},
                                                           'args': [],
                                                           'defaults': {},
                                                           'deprecated': False,
                                                           'doc': 'Returns 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': {},
                                                           'types': {}}],
                                     'invertAttenuation': [{'argInfo': {},
                                                            'args': [],
                                                            'defaults': {},
                                                            'deprecated': False,
                                                            'doc': 'Returns 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': {},
                                                            'types': {}}],
                                     'setDirection': [{'argInfo': {'direction': {'doc': 'A vector representing direction.',
                                                                                 'type': 'MVector'}},
                                                       'args': [('direction',
                                                                 'MVector',
                                                                 'in')],
                                                       'defaults': {},
                                                       'deprecated': False,
                                                       'doc': 'Sets 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': 'Sets the directional speed attribute for the field force.',
                                                              'inArgs': ['speed'],
                                                              'inverse': ('directionalSpeed',
                                                                          True),
                                                              'outArgs': [],
                                                              'returnInfo': {'doc': '',
                                                                             'qualifiers': [],
                                                                             'type': None},
                                                              'returnType': None,
                                                              'static': False,
                                                              'typeQualifiers': {},
                                                              'types': {'speed': 'double'}}],
                                     'setInvertAttenuation': [{'argInfo': {'enable': {'doc': 'Flag to invert falloff of intensity.',
                                                                                      'type': 'bool'}},
                                                               'args': [('enable',
                                                                         'bool',
                                                                         'in')],
                                                               'defaults': {},
                                                               'deprecated': False,
                                                               'doc': 'Enables 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': {},
                                                               'types': {'enable': 'bool'}}],
                                     'setSpeedAlongAxis': [{'argInfo': {'speed': {'doc': 'A double representing the speed along axis.',
                                                                                  'type': 'double'}},
                                                            'args': [('speed',
                                                                      'double',
                                                                      'in')],
                                                            'defaults': {},
                                                            'deprecated': False,
                                                            'doc': 'Sets 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': {},
                                                            'types': {'speed': 'double'}}],
                                     'setSpeedAroundAxis': [{'argInfo': {'speed': {'doc': 'A double representing the speed around axis.',
                                                                                   'type': 'double'}},
                                                             'args': [('speed',
                                                                       'double',
                                                                       'in')],
                                                             'defaults': {},
                                                             'deprecated': False,
                                                             'doc': 'Sets 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': {},
                                                             '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': 'Sets 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': {},
                                                               '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': 'Sets 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': {},
                                                                 'types': {'speed': 'double'}}],
                                     'setTurbulence': [{'argInfo': {'value': {'doc': 'A double representing the turbulence intensity.',
                                                                              'type': 'double'}},
                                                        'args': [('value',
                                                                  'double',
                                                                  'in')],
                                                        'defaults': {},
                                                        'deprecated': False,
                                                        'doc': 'Sets the turbulence attribute for the field force.',
                                                        'inArgs': ['value'],
                                                        'inverse': ('turbulence',
                                                                    True),
                                                        'outArgs': [],
                                                        'returnInfo': {'doc': '',
                                                                       'qualifiers': [],
                                                                       'type': None},
                                                        'returnType': None,
                                                        'static': False,
                                                        'typeQualifiers': {},
                                                        'types': {'value': 'double'}}],
                                     'setTurbulenceFrequency': [{'argInfo': {'value': {'doc': 'A vector representing the frequency of turbulence.',
                                                                                       'type': 'MVector'}},
                                                                 'args': [('value',
                                                                           'MVector',
                                                                           'in')],
                                                                 'defaults': {},
                                                                 'deprecated': False,
                                                                 'doc': 'Sets 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': 'Sets 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': 'Sets the turbulence speed attribute for the field force.',
                                                             'inArgs': ['value'],
                                                             'inverse': ('turbulenceSpeed',
                                                                         True),
                                                             'outArgs': [],
                                                             'returnInfo': {'doc': '',
                                                                            'qualifiers': [],
                                                                            'type': None},
                                                             'returnType': None,
                                                             'static': False,
                                                             'typeQualifiers': {},
                                                             'types': {'value': 'double'}}],
                                     'speedAlongAxis': [{'argInfo': {},
                                                         'args': [],
                                                         'defaults': {},
                                                         'deprecated': False,
                                                         'doc': 'Returns 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': {},
                                                         'types': {}}],
                                     'speedAroundAxis': [{'argInfo': {},
                                                          'args': [],
                                                          'defaults': {},
                                                          'deprecated': False,
                                                          'doc': 'Returns 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': {},
                                                          'types': {}}],
                                     'speedAwayFromAxis': [{'argInfo': {},
                                                            'args': [],
                                                            'defaults': {},
                                                            'deprecated': False,
                                                            'doc': 'Returns 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': {},
                                                            'types': {}}],
                                     'speedAwayFromCenter': [{'argInfo': {},
                                                              'args': [],
                                                              'defaults': {},
                                                              'deprecated': False,
                                                              'doc': 'Returns 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': {},
                                                              'types': {}}],
                                     'turbulence': [{'argInfo': {},
                                                     'args': [],
                                                     'defaults': {},
                                                     'deprecated': False,
                                                     'doc': 'Returns 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': {},
                                                     'types': {}}],
                                     'turbulenceFrequency': [{'argInfo': {},
                                                              'args': [],
                                                              'defaults': {},
                                                              'deprecated': False,
                                                              'doc': 'Returns 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': {},
                                                              'types': {}}],
                                     'turbulenceOffset': [{'argInfo': {},
                                                           'args': [],
                                                           'defaults': {},
                                                           'deprecated': False,
                                                           'doc': 'Returns 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': {},
                                                           'types': {}}],
                                     'turbulenceSpeed': [{'argInfo': {},
                                                          'args': [],
                                                          'defaults': {},
                                                          'deprecated': False,
                                                          'doc': 'Returns 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': {},
                                                          'types': {}}],
                                     'type': [{'argInfo': {},
                                               'args': [],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': 'Function set type',
                                               'inArgs': [],
                                               'outArgs': [],
                                               'returnInfo': {'doc': 'the class type.',
                                                              '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': {},
                                               'values': "Enum('MLightShape', {'kBoxVolume': 0, 'kSphereVolume': 1, 'kCylinderVolume': 2, 'kConeVolume': 3})"}},
                     'invertibles': [('setArc', 'arc'),
                                     ('setConeEndRadius', 'coneEndRadius'),
                                     ('setEmitAmbient', 'emitAmbient'),
                                     ('setLightShape', 'lightShape'),
                                     ('setShadowAngle', 'shadowAngle'),
                                     ('setVolumeLightDirection',
                                      'volumeLightDirection')],
                     'methods': {'arc': [{'argInfo': {},
                                          'args': [],
                                          'defaults': {},
                                          'deprecated': False,
                                          'doc': 'Retrieves 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': {},
                                          'types': {}}],
                                 'className': [{'argInfo': {},
                                                'args': [],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': 'Returns the name of this class.',
                                                'inArgs': [],
                                                'outArgs': [],
                                                'returnInfo': {'doc': 'Name of this class.',
                                                               'qualifiers': ['*'],
                                                               'type': 'char'},
                                                'returnType': 'char',
                                                'static': True,
                                                'typeQualifiers': {},
                                                'types': {}}],
                                 'colorRamp': [{'argInfo': {},
                                                'args': [],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': 'Retrieves the "colorRamp" attribute.',
                                                'inArgs': [],
                                                'outArgs': [],
                                                'returnInfo': {'doc': 'The color ramp attribute',
                                                               'qualifiers': [],
                                                               'type': 'MRampAttribute'},
                                                'returnType': 'MRampAttribute',
                                                'static': False,
                                                'typeQualifiers': {},
                                                'types': {}}],
                                 'coneEndRadius': [{'argInfo': {},
                                                    'args': [],
                                                    'defaults': {},
                                                    'deprecated': False,
                                                    'doc': 'Retrieves 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': {},
                                                    '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': 'Creates 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': {},
                                             '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': 'Creates 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': {'parent': ['const',
                                                                           '&']},
                                             'types': {'UIvisible': 'bool',
                                                       'parent': 'MObject',
                                                       'wantTransform': 'bool'}}],
                                 'emitAmbient': [{'argInfo': {},
                                                  'args': [],
                                                  'defaults': {},
                                                  'deprecated': False,
                                                  'doc': 'Retrieves 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': {},
                                                  'types': {}}],
                                 'lightShape': [{'argInfo': {},
                                                 'args': [],
                                                 'defaults': {},
                                                 'deprecated': False,
                                                 'doc': 'Retrieves 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': {},
                                                 'types': {}}],
                                 'penumbraRamp': [{'argInfo': {},
                                                   'args': [],
                                                   'defaults': {},
                                                   'deprecated': False,
                                                   'doc': 'Retrieves the "penumbraRamp" attribute.',
                                                   'inArgs': [],
                                                   'outArgs': [],
                                                   'returnInfo': {'doc': 'The penumbra ramp attribute',
                                                                  'qualifiers': [],
                                                                  'type': 'MRampAttribute'},
                                                   'returnType': 'MRampAttribute',
                                                   'static': False,
                                                   'typeQualifiers': {},
                                                   'types': {}}],
                                 'setArc': [{'argInfo': {'arc': {'doc': 'value to which the attribute will be set.',
                                                                 'type': 'float'}},
                                             'args': [('arc', 'float', 'in')],
                                             'defaults': {},
                                             'deprecated': False,
                                             'doc': 'Sets 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': 'Sets 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': 'Sets 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': 'Sets 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': 'Sets 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': 'Sets 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': 'Retrieves 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': {},
                                                  'types': {}}],
                                 'type': [{'argInfo': {},
                                           'args': [],
                                           'defaults': {},
                                           'deprecated': False,
                                           'doc': 'Function set type',
                                           'inArgs': [],
                                           'outArgs': [],
                                           'returnInfo': {'doc': 'the class type.',
                                                          'qualifiers': [],
                                                          'type': ('MFn',
                                                                   'Type')},
                                           'returnType': ('MFn', 'Type'),
                                           'static': False,
                                           'typeQualifiers': {},
                                           'types': {}}],
                                 'volumeLightDirection': [{'argInfo': {},
                                                           'args': [],
                                                           'defaults': {},
                                                           'deprecated': False,
                                                           'doc': 'Retrieves 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': {},
                                                           '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': "Returns 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': {},
                                           'types': {}}],
                                 'className': [{'argInfo': {},
                                                'args': [],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': 'Returns the name of this class.',
                                                'inArgs': [],
                                                'outArgs': [],
                                                'returnInfo': {'doc': 'Name of this class.',
                                                               'qualifiers': ['*'],
                                                               'type': 'char'},
                                                'returnType': 'char',
                                                'static': True,
                                                'typeQualifiers': {},
                                                'types': {}}],
                                 'setAxis': [{'argInfo': {'axisVector': {'doc': 'A vector representing an axis.',
                                                                         'type': 'MVector'}},
                                              'args': [('axisVector',
                                                        'MVector',
                                                        'in')],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': "Sets 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': 'Function set type',
                                           'inArgs': [],
                                           'outArgs': [],
                                           'returnInfo': {'doc': 'the class type.',
                                                          'qualifiers': [],
                                                          'type': ('MFn',
                                                                   'Type')},
                                           'returnType': ('MFn', 'Type'),
                                           'static': False,
                                           'typeQualifiers': {},
                                           'types': {}}]},
                     'pymelEnums': {},
                     'pymelMethods': {'axis': 'getAxis'}},
  'MFnWeightGeometryFilter': {'enums': {},
                              'methods': {'className': [{'argInfo': {},
                                                         'args': [],
                                                         'defaults': {},
                                                         'deprecated': False,
                                                         'doc': 'Returns the name of this class.',
                                                         'inArgs': [],
                                                         'outArgs': [],
                                                         'returnInfo': {'doc': 'Name of this class.',
                                                                        'qualifiers': ['*'],
                                                                        'type': 'char'},
                                                         'returnType': 'char',
                                                         'static': True,
                                                         'typeQualifiers': {},
                                                         'types': {}}],
                                          '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': 'Set 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'}}],
                                          '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': 'Gets 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': 'Gets 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': 'Sets 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',
                                                                                     '&']},
                                                         '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': 'Sets 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',
                                                                                     '&']},
                                                         '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': 'Sets 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': 'Sets 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': 'Function set type',
                                                    'inArgs': [],
                                                    'outArgs': [],
                                                    'returnInfo': {'doc': 'the class type.',
                                                                   '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': 'Sets 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': {'list': ['const',
                                                                                             '&']},
                                                                 'types': {'list': 'MSelectionList'}}]},
                              'pymelEnums': {}},
  'MFnWireDeformer': {'enums': {},
                      'invertibles': [('setCrossingEffect', 'crossingEffect'),
                                      ('setDropoffLocator',
                                       'getDropoffLocator'),
                                      ('setEnvelope', 'envelope'),
                                      ('setHoldingShape', 'holdingShape'),
                                      ('setLocalIntensity', 'localIntensity'),
                                      ('setRotation', 'rotation'),
                                      ('setWireDropOffDistance',
                                       'wireDropOffDistance'),
                                      ('setWireScale', 'wireScale')],
                      'methods': {'addGeometry': [{'argInfo': {'object': {'doc': 'the geometry',
                                                                          'type': 'MObject'}},
                                                   'args': [('object',
                                                             'MObject',
                                                             'in')],
                                                   'defaults': {},
                                                   'deprecated': False,
                                                   'doc': 'Adds 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': 'Adds 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': 'Returns the name of this class.',
                                                 'inArgs': [],
                                                 'outArgs': [],
                                                 'returnInfo': {'doc': 'Name of this class.',
                                                                'qualifiers': ['*'],
                                                                'type': 'char'},
                                                 'returnType': 'char',
                                                 'static': True,
                                                 'typeQualifiers': {},
                                                 'types': {}}],
                                  'create': [{'argInfo': {},
                                              'args': [],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': "Creates 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': {},
                                              'types': {}}],
                                  'crossingEffect': [{'argInfo': {},
                                                      'args': [],
                                                      'defaults': {},
                                                      'deprecated': False,
                                                      'doc': 'Returns 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': {},
                                                      'types': {}}],
                                  'envelope': [{'argInfo': {},
                                                'args': [],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': 'Returns the envelope for this deformer.',
                                                'inArgs': [],
                                                'inverse': ('setEnvelope',
                                                            False),
                                                'outArgs': [],
                                                'returnInfo': {'doc': 'The envelope value',
                                                               'qualifiers': [],
                                                               'type': 'float'},
                                                'returnType': 'float',
                                                'static': False,
                                                'typeQualifiers': {},
                                                'types': {}}],
                                  'getAffectedGeometry': [{'argInfo': {'objects': {'doc': 'storage for the returned array',
                                                                                   'type': 'MObjectArray'}},
                                                           'args': [('objects',
                                                                     'MObjectArray',
                                                                     'out')],
                                                           'defaults': {},
                                                           'deprecated': False,
                                                           'doc': 'The 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': 'Gets 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': 'Returns 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': {'wireIndex': ['unsigned']},
                                                    'types': {'wireIndex': 'uint'}}],
                                  'localIntensity': [{'argInfo': {},
                                                      'args': [],
                                                      'defaults': {},
                                                      'deprecated': False,
                                                      'doc': 'Returns 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': {},
                                                      'types': {}}],
                                  'numDropoffLocators': [{'argInfo': {'wireIndex': {'doc': 'the index of the wire curve to query',
                                                                                    'type': 'uint'}},
                                                          'args': [('wireIndex',
                                                                    'uint',
                                                                    'in')],
                                                          'defaults': {},
                                                          'deprecated': False,
                                                          'doc': 'Returns the number of drop off locators.',
                                                          'inArgs': ['wireIndex'],
                                                          'outArgs': [],
                                                          'returnInfo': {'doc': 'The number of drop off locators for the given curve',
                                                                         'qualifiers': [],
                                                                         'type': 'uint'},
                                                          'returnType': 'uint',
                                                          'static': False,
                                                          'typeQualifiers': {'wireIndex': ['unsigned']},
                                                          'types': {'wireIndex': 'uint'}}],
                                  'numWires': [{'argInfo': {},
                                                'args': [],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': 'returns the number of wire curves connected to this deformer.',
                                                'inArgs': [],
                                                'outArgs': [],
                                                'returnInfo': {'doc': 'The number of wires',
                                                               'qualifiers': [],
                                                               'type': 'uint'},
                                                'returnType': 'uint',
                                                'static': False,
                                                'typeQualifiers': {},
                                                'types': {}}],
                                  'removeGeometry': [{'argInfo': {'object': {'doc': 'the geometry',
                                                                             'type': 'MObject'}},
                                                      'args': [('object',
                                                                'MObject',
                                                                'in')],
                                                      'defaults': {},
                                                      'deprecated': False,
                                                      'doc': 'Removes 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': 'Returns the rotation value for this deformer.',
                                                'inArgs': [],
                                                'inverse': ('setRotation',
                                                            False),
                                                'outArgs': [],
                                                'returnInfo': {'doc': 'The rotation value',
                                                               'qualifiers': [],
                                                               'type': 'float'},
                                                'returnType': 'float',
                                                'static': False,
                                                'typeQualifiers': {},
                                                'types': {}}],
                                  'setCrossingEffect': [{'argInfo': {'crossingEffect': {'doc': 'New crossing effect value',
                                                                                        'type': 'float'}},
                                                         'args': [('crossingEffect',
                                                                   'float',
                                                                   'in')],
                                                         'defaults': {},
                                                         'deprecated': False,
                                                         'doc': 'Sets the crossing effect for this wire deformer.',
                                                         'inArgs': ['crossingEffect'],
                                                         'inverse': ('crossingEffect',
                                                                     True),
                                                         'outArgs': [],
                                                         'returnInfo': {'doc': '',
                                                                        'qualifiers': [],
                                                                        'type': None},
                                                         'returnType': None,
                                                         'static': False,
                                                         'typeQualifiers': {},
                                                         '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': 'Sets 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'],
                                                                            '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': 'Sets the envelope for this deformer.',
                                                   'inArgs': ['envelope'],
                                                   'inverse': ('envelope',
                                                               True),
                                                   'outArgs': [],
                                                   'returnInfo': {'doc': '',
                                                                  'qualifiers': [],
                                                                  'type': None},
                                                   'returnType': None,
                                                   'static': False,
                                                   'typeQualifiers': {},
                                                   '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': 'Sets 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': {'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': 'Sets the local intensity for this wire deformer.',
                                                         'inArgs': ['localIntensity'],
                                                         'inverse': ('localIntensity',
                                                                     True),
                                                         'outArgs': [],
                                                         'returnInfo': {'doc': '',
                                                                        'qualifiers': [],
                                                                        'type': None},
                                                         'returnType': None,
                                                         'static': False,
                                                         'typeQualifiers': {},
                                                         'types': {'localIntensity': 'float'}}],
                                  'setRotation': [{'argInfo': {'rotation': {'doc': 'new rotation value',
                                                                            'type': 'float'}},
                                                   'args': [('rotation',
                                                             'float',
                                                             'in')],
                                                   'defaults': {},
                                                   'deprecated': False,
                                                   'doc': 'Sets the rotation value for this deformer.',
                                                   'inArgs': ['rotation'],
                                                   'inverse': ('rotation',
                                                               True),
                                                   'outArgs': [],
                                                   'returnInfo': {'doc': '',
                                                                  'qualifiers': [],
                                                                  'type': None},
                                                   'returnType': None,
                                                   'static': False,
                                                   'typeQualifiers': {},
                                                   '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': 'Sets 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': {'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': 'Sets 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': {'wireIndex': ['unsigned']},
                                                    'types': {'scale': 'float',
                                                              'wireIndex': 'uint'}}],
                                  'type': [{'argInfo': {},
                                            'args': [],
                                            'defaults': {},
                                            'deprecated': False,
                                            'doc': 'Function set type',
                                            'inArgs': [],
                                            'outArgs': [],
                                            'returnInfo': {'doc': 'the class type.',
                                                           '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': 'Return 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': {'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': 'Return 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': {'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': 'Return 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': {'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': {},
                       '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})"}},
                    'methods': {},
                    '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)"}},
  'MGeometryLegacy': {'enums': {}, 'methods': {}, 'pymelEnums': {}},
  'MGeometryList': {'constants': {'kAll': -1,
                                  'kCulling': 4,
                                  'kFixedFunctionLighting': 2,
                                  'kMatrices': 1,
                                  'kNone': 0},
                    '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': {},
                    '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': {},
                       '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': {},
                         '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': {}, '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 (MLibrary) application.',
                                                     'libraryApp': 'Running as a standalone (MLibrary) application.'},
                                       '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})"}},
              'methods': {},
              '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)"}},
  '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). Note: this is not currently supported',
                                                                  'kAnimCurveSelected': 'Curve(s) selected (via keys/tangent handles) in the viewport.',
                                                                  'outlinerOnly': 'Curve(s) present in Outliner (but not visible in the viewport). Note: this is not currently supported',
                                                                  'selected': 'Curve(s) selected (via keys/tangent handles) in the viewport.'},
                                                    'values': "Enum('AnimCurveQuery', {'kAnimCurveOutlinerOnly': 0, 'kAnimCurveHighlighted': 1, 'kAnimCurveSelected': 2, 'kAnimCurveAllKnown': 3})"}},
                       'methods': {},
                       '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': {}, 'pymelEnums': {}},
  'MHairSystem': {'enums': {}, 'methods': {}, 'pymelEnums': {}},
  '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': {},
                        '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': {}, 'pymelEnums': {}},
  'MHwrCallback': {'enums': {}, 'methods': {}, 'pymelEnums': {}},
  'MIffFile': {'enums': {}, 'methods': {}, 'pymelEnums': {}},
  'MIffTag': {'enums': {}, 'methods': {}, 'pymelEnums': {}},
  'MIkHandleGroup': {'enums': {}, 'methods': {}, 'pymelEnums': {}},
  'MIkSystem': {'enums': {}, 'methods': {}, 'pymelEnums': {}},
  'MImage': {'enums': {'MImageFilterFormat': {'valueDocs': {},
                                              '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})"}},
             'methods': {},
             '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)"}},
  'MImageFileInfo': {'enums': {'MHwTextureType': {'valueDocs': {},
                                                  'values': "Enum('MHwTextureType', {'kHwTextureUnknown': 0, 'kHwTexture1D': 1, 'kHwTexture2D': 2, 'kHwTexture3D': 3, 'kHwTextureRectangle': 4, 'kHwTextureCubeMap': 5})"},
                               'MImageType': {'valueDocs': {},
                                              'values': "Enum('MImageType', {'kImageTypeUnknown': 0, 'kImageTypeColor': 1, 'kImageTypeNormal': 2, 'kImageTypeBump': 3})"}},
                     'methods': {},
                     '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': {}, 'methods': {}, 'pymelEnums': {}},
  'MIntArray': {'enums': {}, 'methods': {}, 'pymelEnums': {}},
  'MItCurveCV': {'enums': {},
                 'invertibles': [('setPosition', 'position')],
                 'methods': {'className': [{'argInfo': {},
                                            'args': [],
                                            'defaults': {},
                                            'deprecated': False,
                                            'doc': 'Returns the name of this class.',
                                            'inArgs': [],
                                            'outArgs': [],
                                            'returnInfo': {'doc': 'The name of this class.',
                                                           'qualifiers': ['*'],
                                                           'type': 'char'},
                                            'returnType': 'char',
                                            'static': True,
                                            'typeQualifiers': {},
                                            'types': {}}],
                             'currentItem': [{'argInfo': {},
                                              'args': [],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': 'This 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': {},
                                              'types': {}}],
                             'cv': [{'argInfo': {},
                                     'args': [],
                                     'defaults': {},
                                     'deprecated': True,
                                     'doc': 'This method is obsolete. [as of Maya 2019]',
                                     'inArgs': [],
                                     'outArgs': [],
                                     'returnInfo': {'doc': 'A handle to the CV requested',
                                                    'qualifiers': [],
                                                    'type': 'MObject'},
                                     'returnType': 'MObject',
                                     'static': False,
                                     'typeQualifiers': {},
                                     'types': {}}],
                             'hasHistoryOnCreate': [{'argInfo': {},
                                                     'args': [],
                                                     'defaults': {},
                                                     'deprecated': False,
                                                     'doc': 'This 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': {},
                                                     'types': {}}],
                             'index': [{'argInfo': {},
                                        'args': [],
                                        'defaults': {},
                                        'deprecated': False,
                                        'doc': 'This 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': {},
                                        'types': {}}],
                             'isDone': [{'argInfo': {},
                                         'args': [],
                                         'defaults': {},
                                         'deprecated': False,
                                         'doc': 'Returns 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': {},
                                         'types': {}}],
                             'next': [{'argInfo': {},
                                       'args': [],
                                       'defaults': {},
                                       'deprecated': False,
                                       'doc': 'Advance 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': 'Return the position of the current CV.',
                                           'inArgs': ['space'],
                                           'inverse': ('setPosition', False),
                                           'outArgs': [],
                                           'returnInfo': {'doc': 'Status code',
                                                          'qualifiers': [],
                                                          'type': 'MPoint'},
                                           'returnType': 'MPoint',
                                           'static': False,
                                           'typeQualifiers': {},
                                           'types': {'space': ('MSpace',
                                                               'Space')}}],
                             'reset': [{'argInfo': {},
                                        'args': [],
                                        'defaults': {},
                                        'deprecated': False,
                                        'doc': 'Reset 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': 'Reset 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': 'Reset 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': 'Set 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',
                                                                        '&']},
                                              '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': 'Translates the current CV by the amount specified in vec.',
                                              'inArgs': ['vec', 'space'],
                                              'outArgs': [],
                                              'returnInfo': {'doc': '',
                                                             'qualifiers': [],
                                                             'type': None},
                                              'returnType': None,
                                              'static': False,
                                              'typeQualifiers': {'vec': ['const',
                                                                         '&']},
                                              'types': {'space': ('MSpace',
                                                                  'Space'),
                                                        'vec': 'MVector'}}],
                             'updateCurve': [{'argInfo': {},
                                              'args': [],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': 'This 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})"},
                                   'Relationship': {'valueDocs': {'connectedTo': 'Traverse DG connection.',
                                                                  'dependsOn': 'Traverse dependency (this is the default behavior)',
                                                                  'evaluationGraph': 'Traverse evaluation graph.',
                                                                  'kConnectedTo': 'Traverse DG connection.',
                                                                  'kDependsOn': 'Traverse dependency (this is the default behavior)',
                                                                  'kEvaluationGraph': 'Traverse evaluation graph.'},
                                                    'values': "Enum('Relationship', {'kDependsOn': 0, 'kConnectedTo': 1, 'kEvaluationGraph': 2})"},
                                   '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})"}},
                         'methods': {},
                         '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)",
                                        'Relationship': "Enum('Relationship', [('dependsOn', 0), ('kDependsOn', 0), ('connectedTo', 1), ('kConnectedTo', 1), ('evaluationGraph', 2), ('kEvaluationGraph', 2)], multiKeys=True)",
                                        'Traversal': "Enum('Traversal', [('depthFirst', 0), ('kDepthFirst', 0), ('breadthFirst', 1), ('kBreadthFirst', 1)], multiKeys=True)"}},
  'MItDependencyNodes': {'enums': {}, 'methods': {}, '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': {},
               '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': {}, 'methods': {}, 'pymelEnums': {}},
  'MItInstancer': {'enums': {}, 'methods': {}, '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.',
                                                          'autoCustom': 'The first and last keyframes will have flat tangents. Between, inner keyframes, the animation curve will not over shoot the keyframe values, and use a custom cubic interpolation to calculate the auto tangent.',
                                                          'autoEase': 'The first and last keyframes will have flat tangents. Between, inner keyframes, the animation curve will not over shoot the keyframe values, and use a cubic interpolation to calculate the auto tangent.',
                                                          'autoMix': 'The first and last keyframes will have flat tangents. Between, inner keyframes, the animation curve will not over shoot the keyframe values, and use a linear interpolation to calculate the auto tangent.',
                                                          '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).\nIf a tangent is set to be fixed then it will not change when keys are moved but will retain its current value.',
                                                          '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.',
                                                          'kTangentAutoCustom': 'The first and last keyframes will have flat tangents. Between, inner keyframes, the animation curve will not over shoot the keyframe values, and use a custom cubic interpolation to calculate the auto tangent.',
                                                          'kTangentAutoEase': 'The first and last keyframes will have flat tangents. Between, inner keyframes, the animation curve will not over shoot the keyframe values, and use a cubic interpolation to calculate the auto tangent.',
                                                          'kTangentAutoMix': 'The first and last keyframes will have flat tangents. Between, inner keyframes, the animation curve will not over shoot the keyframe values, and use a linear interpolation to calculate the auto tangent.',
                                                          '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).\nIf a tangent is set to be fixed then it will not change when keys are moved but will retain its current value.',
                                                          '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, 'kTangentAutoMix': 12, 'kTangentAutoEase': 13, 'kTangentAutoCustom': 14})"}},
                  'methods': {},
                  '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), ('autoMix', 12), ('kTangentAutoMix', 12), ('autoEase', 13), ('kTangentAutoEase', 13), ('autoCustom', 14), ('kTangentAutoCustom', 14)], multiKeys=True)"}},
  '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': 'Returns 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': {},
                                          'types': {'space': ('MSpace',
                                                              'Space')}}],
                              'className': [{'argInfo': {},
                                             'args': [],
                                             'defaults': {},
                                             'deprecated': False,
                                             'doc': 'Returns the name of this class.',
                                             'inArgs': [],
                                             'outArgs': [],
                                             'returnInfo': {'doc': 'The name of this class.',
                                                            'qualifiers': ['*'],
                                                            'type': 'char'},
                                             'returnType': 'char',
                                             'static': True,
                                             'typeQualifiers': {},
                                             'types': {}}],
                              'cleanupSmoothing': [{'argInfo': {},
                                                    'args': [],
                                                    'defaults': {},
                                                    'deprecated': True,
                                                    'doc': 'This method is obsolete. [as of Maya 2019]',
                                                    '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': 'This 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': {},
                                                   'types': {'index': 'int'}}],
                              'connectedToFace': [{'argInfo': {'index': {'doc': 'Index of face to check.',
                                                                         'type': 'int'}},
                                                   'args': [('index',
                                                             'int',
                                                             'in')],
                                                   'defaults': {},
                                                   'deprecated': False,
                                                   'doc': 'This 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': {},
                                                   'types': {'index': 'int'}}],
                              'count': [{'argInfo': {},
                                         'args': [],
                                         'defaults': {},
                                         'deprecated': False,
                                         'doc': 'Return 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': {},
                                         'types': {}}],
                              'currentItem': [{'argInfo': {},
                                               'args': [],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': 'Get 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': {},
                                               'types': {}}],
                              'edge': [{'argInfo': {},
                                        'args': [],
                                        'defaults': {},
                                        'deprecated': True,
                                        'doc': 'This method is obsolete. [from before Maya 2016]',
                                        'inArgs': [],
                                        'outArgs': [],
                                        'returnInfo': {'doc': 'The current edge in the interation',
                                                       'qualifiers': [],
                                                       'type': 'MObject'},
                                        'returnType': 'MObject',
                                        'static': False,
                                        'typeQualifiers': {},
                                        'types': {}}],
                              'geomChanged': [{'argInfo': {},
                                               'args': [],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': "Reset 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': [('edges',
                                                               'MIntArray',
                                                               'out')],
                                                     'defaults': {},
                                                     'deprecated': False,
                                                     'doc': 'This method returns a list of edges connected to the current edge.',
                                                     'inArgs': [],
                                                     'outArgs': ['edges'],
                                                     'returnInfo': {'doc': 'Number of connected edges',
                                                                    'qualifiers': [],
                                                                    'type': 'int'},
                                                     'returnType': 'int',
                                                     'static': False,
                                                     'typeQualifiers': {'edges': ['&']},
                                                     'types': {'edges': 'MIntArray'}}],
                              'getConnectedFaces': [{'argInfo': {'faces': {'doc': 'Array of face indices.',
                                                                           'type': 'MIntArray'}},
                                                     'args': [('faces',
                                                               'MIntArray',
                                                               'out')],
                                                     'defaults': {},
                                                     'deprecated': False,
                                                     'doc': 'This 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': ['faces'],
                                                     'returnInfo': {'doc': 'Number of connected faces',
                                                                    'qualifiers': [],
                                                                    'type': 'int'},
                                                     'returnType': 'int',
                                                     'static': False,
                                                     'typeQualifiers': {'faces': ['&']},
                                                     'types': {'faces': 'MIntArray'}}],
                              'getLength': [{'argInfo': {'length': {'doc': 'length of edge',
                                                                    'type': 'double',
                                                                    'unitType': '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': 'This method returns the length of the current edge.',
                                             'inArgs': ['space'],
                                             'outArgs': ['length'],
                                             'returnInfo': {'doc': '',
                                                            'qualifiers': [],
                                                            'type': None},
                                             'returnType': None,
                                             'static': False,
                                             'typeQualifiers': {'length': ['&']},
                                             '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': 'This 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': {},
                                         'types': {'index': 'int'}},
                                        {'argInfo': {},
                                         'args': [],
                                         'defaults': {},
                                         'deprecated': False,
                                         'doc': 'This method returns the index of the current edge in the iteration.',
                                         'inArgs': [],
                                         'inverse': ('setIndex', False),
                                         'outArgs': [],
                                         'returnInfo': {'doc': 'The index of the current edge in the iteration',
                                                        'qualifiers': [],
                                                        'type': 'int'},
                                         'returnType': 'int',
                                         'static': False,
                                         'typeQualifiers': {},
                                         'types': {}}],
                              'isDone': [{'argInfo': {},
                                          'args': [],
                                          'defaults': {},
                                          'deprecated': False,
                                          'doc': 'Indicates 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': {},
                                          'types': {}}],
                              'isSmooth': [{'argInfo': {},
                                            'args': [],
                                            'defaults': {},
                                            'deprecated': False,
                                            'doc': 'This 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': {},
                                            'types': {}}],
                              'next': [{'argInfo': {},
                                        'args': [],
                                        'defaults': {},
                                        'deprecated': False,
                                        'doc': 'Advance 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': [('edgeCount',
                                                               'int',
                                                               'out')],
                                                     'defaults': {},
                                                     'deprecated': False,
                                                     'doc': 'This method returns the number of edges connected to the current edge.',
                                                     'inArgs': [],
                                                     'outArgs': ['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': 'This 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': 'This 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': {},
                                              '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': 'Return 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': {},
                                         'types': {'index': 'int',
                                                   'space': ('MSpace',
                                                             'Space')}}],
                              'reset': [{'argInfo': {},
                                         'args': [],
                                         'defaults': {},
                                         'deprecated': False,
                                         'doc': 'Reset 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': 'Reset 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': 'Reset 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': 'This 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': {'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': 'Set 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',
                                                                         '&']},
                                            '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': 'This 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': {},
                                                'types': {'smooth': 'bool'}}],
                              'updateSurface': [{'argInfo': {},
                                                 'args': [],
                                                 'defaults': {},
                                                 'deprecated': False,
                                                 'doc': 'Signal 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': {}, 'pymelEnums': {}},
  'MItMeshPolygon': {'enums': {},
                     'invertibles': [('setIndex', 'index'),
                                     ('setPoint', 'point'),
                                     ('setPoints', 'getPoints'),
                                     ('setUV', 'getUV'),
                                     ('setUVs', 'getUVs')],
                     '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': 'Return 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': {},
                                             'types': {'space': ('MSpace',
                                                                 'Space')}}],
                                 'className': [{'argInfo': {},
                                                'args': [],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': 'Returns the name of this class.',
                                                'inArgs': [],
                                                'outArgs': [],
                                                'returnInfo': {'doc': 'The name of this class.',
                                                               'qualifiers': ['*'],
                                                               'type': 'char'},
                                                'returnType': 'char',
                                                'static': True,
                                                'typeQualifiers': {},
                                                'types': {}}],
                                 'count': [{'argInfo': {},
                                            'args': [],
                                            'defaults': {},
                                            'deprecated': False,
                                            'doc': 'Return the number of polygons in the iteration.',
                                            'inArgs': [],
                                            'outArgs': [],
                                            'returnInfo': {'doc': 'The number of polygons in the iteration',
                                                           'qualifiers': [],
                                                           'type': 'uint'},
                                            'returnType': 'uint',
                                            'static': False,
                                            'typeQualifiers': {},
                                            'types': {}}],
                                 'currentItem': [{'argInfo': {},
                                                  'args': [],
                                                  'defaults': {},
                                                  'deprecated': False,
                                                  'doc': 'Get 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': {},
                                                  'types': {}}],
                                 'geomChanged': [{'argInfo': {},
                                                  'args': [],
                                                  'defaults': {},
                                                  'deprecated': False,
                                                  'doc': 'Reset 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': 'This method gets the area of the face',
                                              'inArgs': ['space'],
                                              'outArgs': ['area'],
                                              'returnInfo': {'doc': '',
                                                             'qualifiers': [],
                                                             'type': None},
                                              'returnType': None,
                                              'static': False,
                                              'typeQualifiers': {'area': ['&']},
                                              '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': 'Return 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': ['&'],
                                                                     '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': 'This 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': 'This 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': ['&']},
                                               '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': 'This 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',
                                                                                        '*']},
                                                    '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': 'This 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': 'This 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': 'This 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': 'This 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': 'This 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': 'This 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': 'Return the face normal of the current polygon.',
                                                'inArgs': ['space'],
                                                'outArgs': ['normal'],
                                                'returnInfo': {'doc': '',
                                                               'qualifiers': [],
                                                               'type': None},
                                                'returnType': None,
                                                'static': False,
                                                'typeQualifiers': {'normal': ['&']},
                                                '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': 'Returns 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': ['&']},
                                                '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': 'Returns the normals for all vertices in the current face',
                                                 'inArgs': ['space'],
                                                 'outArgs': ['normalArray'],
                                                 'returnInfo': {'doc': '',
                                                                'qualifiers': [],
                                                                'type': None},
                                                 'returnType': None,
                                                 'static': False,
                                                 'typeQualifiers': {'normalArray': ['&']},
                                                 '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': 'Return 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': ['&'],
                                                                      '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': 'Retrieves 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': {'pointArray': ['&']},
                                                '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': "Get 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': {'points': ['&'],
                                                                     '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': "Get 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': ['&'],
                                                                      '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': 'Return 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',
                                                                         '*']},
                                            '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': 'This 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': 'Find 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': ['&'],
                                                                      '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': 'Returns 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',
                                                                              '*']},
                                                 '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': 'Return 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': ['&']},
                                                 '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': 'This 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': 'Return 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': 'This 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': 'This 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': {},
                                               'types': {}},
                                              {'argInfo': {'vertexIndex': {'doc': 'face-relative vertex index to check for color on',
                                                                           'type': 'int'}},
                                               'args': [('vertexIndex',
                                                         'int',
                                                         'in')],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': 'This 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': {},
                                               'types': {'vertexIndex': 'int'}}],
                                 'hasUVs': [{'argInfo': {},
                                             'args': [],
                                             'defaults': {},
                                             'deprecated': False,
                                             'doc': "Tests 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': {},
                                             'types': {}},
                                            {'argInfo': {'uvSet': {'doc': 'UV set to work with',
                                                                   'type': 'MString'}},
                                             'args': [('uvSet',
                                                       'MString',
                                                       'in')],
                                             'defaults': {},
                                             'deprecated': False,
                                             'doc': "Tests 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': {'uvSet': ['const',
                                                                          '&']},
                                             'types': {'uvSet': 'MString'}}],
                                 'hasValidTriangulation': [{'argInfo': {},
                                                            'args': [],
                                                            'defaults': {},
                                                            'deprecated': False,
                                                            'doc': "This 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': {},
                                                            'types': {}}],
                                 'index': [{'argInfo': {},
                                            'args': [],
                                            'defaults': {},
                                            'deprecated': False,
                                            'doc': 'Returns the index of the current polygon.',
                                            'inArgs': [],
                                            'inverse': ('setIndex', False),
                                            'outArgs': [],
                                            'returnInfo': {'doc': 'The index of the current polygon',
                                                           'qualifiers': [],
                                                           'type': 'uint'},
                                            'returnType': 'uint',
                                            'static': False,
                                            'typeQualifiers': {},
                                            'types': {}}],
                                 'isConnectedToEdge': [{'argInfo': {'index': {'doc': 'Index of the edge to be tested for',
                                                                              'type': 'int'}},
                                                        'args': [('index',
                                                                  'int',
                                                                  'in')],
                                                        'defaults': {},
                                                        'deprecated': False,
                                                        'doc': 'This 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': {},
                                                        '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': 'This 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': {},
                                                        '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': 'This 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': {},
                                                          'types': {'index': 'int'}}],
                                 'isConvex': [{'argInfo': {},
                                               'args': [],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': 'This 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': {},
                                               'types': {}}],
                                 'isDone': [{'argInfo': {},
                                             'args': [],
                                             'defaults': {},
                                             'deprecated': False,
                                             'doc': 'Indicates 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': {},
                                             'types': {}}],
                                 'isHoled': [{'argInfo': {},
                                              'args': [],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': 'This 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': {},
                                              'types': {}}],
                                 'isLamina': [{'argInfo': {},
                                               'args': [],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': 'This 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': {},
                                               'types': {}}],
                                 'isPlanar': [{'argInfo': {},
                                               'args': [],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': 'This 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': {},
                                               'types': {}}],
                                 'isStarlike': [{'argInfo': {},
                                                 'args': [],
                                                 'defaults': {},
                                                 'deprecated': False,
                                                 'doc': 'This 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': {},
                                                 'types': {}}],
                                 'isUVReversed': [{'argInfo': {'uvSet': {'doc': 'UV set to work with',
                                                                         'type': 'MString'}},
                                                   'args': [('uvSet',
                                                             'MString',
                                                             'in')],
                                                   'defaults': {'uvSet': None},
                                                   'deprecated': False,
                                                   'doc': "This 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': {'uvSet': ['const',
                                                                                '*']},
                                                   'types': {'uvSet': 'MString'}}],
                                 'next': [{'argInfo': {},
                                           'args': [],
                                           'defaults': {},
                                           'deprecated': False,
                                           'doc': 'Advance 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': 'Returns 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': 'uint'},
                                                  'returnType': 'uint',
                                                  'static': False,
                                                  'typeQualifiers': {},
                                                  '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': 'This 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': 'This 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': 'This 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': 'This 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': 'This 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': {},
                                                 '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': 'Return 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': {},
                                            'types': {'index': 'int',
                                                      'space': ('MSpace',
                                                                'Space')}}],
                                 'polygon': [{'argInfo': {},
                                              'args': [],
                                              'defaults': {},
                                              'deprecated': True,
                                              'doc': 'This method is obsolete. [as of Maya 2019]',
                                              'inArgs': [],
                                              'outArgs': [],
                                              'returnInfo': {'doc': 'The current polygon in the iteration',
                                                             'qualifiers': [],
                                                             'type': 'MObject'},
                                              'returnType': 'MObject',
                                              'static': False,
                                              'typeQualifiers': {},
                                              'types': {}}],
                                 'polygonVertexCount': [{'argInfo': {},
                                                         'args': [],
                                                         'defaults': {},
                                                         'deprecated': False,
                                                         'doc': 'Return the number of vertices for the current polygon.',
                                                         'inArgs': [],
                                                         'outArgs': [],
                                                         'returnInfo': {'doc': 'The number of vertices for the current polygon',
                                                                        'qualifiers': [],
                                                                        'type': 'uint'},
                                                         'returnType': 'uint',
                                                         'static': False,
                                                         'typeQualifiers': {},
                                                         'types': {}}],
                                 'reset': [{'argInfo': {},
                                            'args': [],
                                            'defaults': {},
                                            'deprecated': False,
                                            'doc': 'Reset 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': 'Reset 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': 'Reset 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': 'This 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': {'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': 'Set 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',
                                                                            '&']},
                                               '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': 'Sets 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': ['&']},
                                                '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': 'Modify 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',
                                                                         '*']},
                                            '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': 'Modify 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': 'Returns 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': 'uint'},
                                                   'returnType': 'uint',
                                                   'static': False,
                                                   'typeQualifiers': {},
                                                   'types': {'localVertexIndex': 'int'}}],
                                 'updateSurface': [{'argInfo': {},
                                                    'args': [],
                                                    'defaults': {},
                                                    'deprecated': False,
                                                    'doc': 'Signal 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': 'Returns 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': 'uint'},
                                                  'returnType': 'uint',
                                                  'static': False,
                                                  'typeQualifiers': {},
                                                  'types': {'index': 'int'}}],
                                 'zeroArea': [{'argInfo': {},
                                               'args': [],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': 'This 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': {},
                                               'types': {}}],
                                 'zeroUVArea': [{'argInfo': {},
                                                 'args': [],
                                                 'defaults': {},
                                                 'deprecated': False,
                                                 'doc': 'This 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': {},
                                                 'types': {}},
                                                {'argInfo': {'uvSet': {'doc': 'UV set to work with',
                                                                       'type': 'MString'}},
                                                 'args': [('uvSet',
                                                           'MString',
                                                           'in')],
                                                 'defaults': {},
                                                 'deprecated': False,
                                                 'doc': 'This 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': {'uvSet': ['const',
                                                                              '&']},
                                                 'types': {'uvSet': 'MString'}}]},
                     'pymelEnums': {},
                     'pymelMethods': {'index': 'getIndex',
                                      'point': 'getPoint'}},
  'MItMeshVertex': {'enums': {},
                    'invertibles': [('setIndex', 'index'),
                                    ('setPosition', 'position'),
                                    ('setUV', 'getUV'),
                                    ('setUVs', 'getUVs')],
                    'methods': {'className': [{'argInfo': {},
                                               'args': [],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': 'Returns the name of this class.',
                                               'inArgs': [],
                                               'outArgs': [],
                                               'returnInfo': {'doc': 'The name of this class.',
                                                              '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': 'This 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': {},
                                                     'types': {'index': 'int'}}],
                                'connectedToFace': [{'argInfo': {'index': {'doc': 'Index of face to check.',
                                                                           'type': 'int'}},
                                                     'args': [('index',
                                                               'int',
                                                               'in')],
                                                     'defaults': {},
                                                     'deprecated': False,
                                                     'doc': 'This 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': {},
                                                     'types': {'index': 'int'}}],
                                'count': [{'argInfo': {},
                                           'args': [],
                                           'defaults': {},
                                           'deprecated': False,
                                           'doc': 'Return 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': {},
                                           'types': {}}],
                                'currentItem': [{'argInfo': {},
                                                 'args': [],
                                                 'defaults': {},
                                                 'deprecated': False,
                                                 'doc': 'Get 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': {},
                                                 'types': {}}],
                                'geomChanged': [{'argInfo': {},
                                                 'args': [],
                                                 'defaults': {},
                                                 'deprecated': False,
                                                 'doc': "Reset 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': 'This 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',
                                                                                  '*']},
                                              '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': 'This 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': 'This 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': 'This 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': 'This 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': 'This 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': 'This 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': 'Return 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': {'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': 'Return 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': {'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': 'This 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': 'Return the normals of the current vertex for all faces',
                                                'inArgs': ['space'],
                                                'outArgs': ['normalArray'],
                                                'returnInfo': {'doc': '',
                                                               'qualifiers': [],
                                                               'type': None},
                                                'returnType': None,
                                                'static': False,
                                                'typeQualifiers': {'normalArray': ['&']},
                                                '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': 'This gets the other vertex of the given edge',
                                                       'inArgs': ['edgeId'],
                                                       'outArgs': ['vertexId'],
                                                       'returnInfo': {'doc': '',
                                                                      'qualifiers': [],
                                                                      'type': None},
                                                       'returnType': None,
                                                       'static': False,
                                                       'typeQualifiers': {'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': 'Get 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': 'Get 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': {'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': 'This 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': 'Get 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': 'This 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': {},
                                              'types': {}},
                                             {'argInfo': {'index': {'doc': 'Index of face to check.',
                                                                    'type': 'int'}},
                                              'args': [('index', 'int', 'in')],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': 'This 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': {},
                                              'types': {'index': 'int'}}],
                                'index': [{'argInfo': {},
                                           'args': [],
                                           'defaults': {},
                                           'deprecated': False,
                                           'doc': 'Returns 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': {},
                                           'types': {}}],
                                'isDone': [{'argInfo': {},
                                            'args': [],
                                            'defaults': {},
                                            'deprecated': False,
                                            'doc': 'Indicates 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': {},
                                            'types': {}}],
                                'next': [{'argInfo': {},
                                          'args': [],
                                          'defaults': {},
                                          'deprecated': False,
                                          'doc': 'Advance 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': 'This 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': 'This 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': 'This 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': 'This 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': {},
                                                'types': {}}],
                                'position': [{'argInfo': {'space': {'doc': 'The transformation space',
                                                                    'type': ('MSpace',
                                                                             'Space')}},
                                              'args': [('space',
                                                        ('MSpace', 'Space'),
                                                        'in')],
                                              'defaults': {'space': ('MSpace',
                                                                     'Space',
                                                                     'kObject')},
                                              'deprecated': False,
                                              'doc': 'Return 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': {},
                                              'types': {'space': ('MSpace',
                                                                  'Space')}}],
                                'reset': [{'argInfo': {},
                                           'args': [],
                                           'defaults': {},
                                           'deprecated': False,
                                           'doc': 'Reset 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': 'Reset 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': 'Reset 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': 'This 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': {'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': 'Set 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',
                                                                              '&']},
                                                 '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': 'Set 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': 'Set 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': {'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': 'Set 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': 'Translate 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': {'vector': ['const',
                                                                               '&']},
                                                 'types': {'space': ('MSpace',
                                                                     'Space'),
                                                           'vector': 'MVector'}}],
                                'updateSurface': [{'argInfo': {},
                                                   'args': [],
                                                   'defaults': {},
                                                   'deprecated': False,
                                                   'doc': 'Signal 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': 'This method is obsolete. [as of Maya 2019]',
                                            'inArgs': [],
                                            'outArgs': [],
                                            'returnInfo': {'doc': 'The current vertex in the interation',
                                                           'qualifiers': [],
                                                           'type': 'MObject'},
                                            'returnType': 'MObject',
                                            'static': False,
                                            'typeQualifiers': {},
                                            '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', {'kUnknownItem': -1, 'kDagSelectionItem': 0, 'kAnimSelectionItem': 1, 'kDNselectionItem': 2, 'kPlugSelectionItem': 3})"}},
                       'methods': {},
                       'pymelEnums': {'selItemType': "Enum('selItemType', [('unknownItem', -1), ('kUnknownItem', -1), ('dagSelectionItem', 0), ('kDagSelectionItem', 0), ('animSelectionItem', 1), ('kAnimSelectionItem', 1), ('DNselectionItem', 2), ('kDNselectionItem', 2), ('plugSelectionItem', 3), ('kPlugSelectionItem', 3)], multiKeys=True)"}},
  'MItSubdEdge': {'enums': {}, 'methods': {}, 'pymelEnums': {}},
  'MItSubdFace': {'enums': {}, 'methods': {}, 'pymelEnums': {}},
  'MItSubdVertex': {'enums': {}, 'methods': {}, 'pymelEnums': {}},
  'MItSurfaceCV': {'enums': {}, 'methods': {}, 'pymelEnums': {}},
  'MIteratorType': {'enums': {'objFilterType': {'valueDocs': {'dagPathObject': 'This is to indicate that the root of the iterator has to be reset to an MDagPath object.',
                                                              'kMDagPathObject': 'This is to indicate that the root of the iterator has to be reset to an MDagPath object.',
                                                              'kMObject': 'This is to indicate that the root of the iterator has to be reset to an MObject.',
                                                              'kMPlugObject': 'This is to indicate that the root of the iterator has to be reset to an MPlug object.',
                                                              'object': 'This is to indicate that the root of the iterator has to be reset to an MObject.',
                                                              'plugObject': 'This is to indicate that the root of the iterator has to be reset to an MPlug object.'},
                                                'values': "Enum('objFilterType', {'kMObject': 0, 'kMDagPathObject': 1, 'kMPlugObject': 2})"}},
                    'methods': {},
                    'pymelEnums': {'objFilterType': "Enum('objFilterType', [('object', 0), ('kMObject', 0), ('dagPathObject', 1), ('kMDagPathObject', 1), ('plugObject', 2), ('kMPlugObject', 2)], multiKeys=True)"}},
  'MLightLinks': {'enums': {}, 'methods': {}, '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': {},
                   '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': {}, 'pymelEnums': {}},
  'MMaterial': {'enums': {'MtextureChannel': {'valueDocs': {'color': 'nop',
                                                            'cosinePower': 'Phong only.',
                                                            'eccentricity': 'Blinn only.',
                                                            'highlightSize': 'PhongE only.',
                                                            'kColor': 'nop',
                                                            'kCosinePower': 'Phong only.',
                                                            'kEccentricity': 'Blinn only.',
                                                            'kHighlightSize': 'PhongE only.',
                                                            'kReflectedColor': 'Blinn and Phong(E) only.',
                                                            'kReflectivity': 'Blinn and Phong(E) only.',
                                                            'kRoughness': 'PhongE only.',
                                                            'kSpecularColor': 'Blinn and Phong(E) only.',
                                                            'kSpecularRollOff': 'Blinn only.',
                                                            '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.',
                                                            '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': {},
                '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': {}, 'methods': {}, 'pymelEnums': {}},
  'MMatrix': {'enums': {},
              'methods': {'__add__': [{'argInfo': {'right': {'doc': 'Matrix to add to this one.',
                                                             'type': 'MMatrix'}},
                                       'args': [('right', 'MMatrix', 'in')],
                                       'defaults': {},
                                       'deprecated': False,
                                       'doc': 'The 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': 'The 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': 'Index 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'}}],
                          '__iadd__': [{'argInfo': {'right': {'doc': 'Matrix to add.',
                                                              'type': 'MMatrix'}},
                                        'args': [('right', 'MMatrix', 'in')],
                                        'defaults': {},
                                        'deprecated': False,
                                        'doc': 'The 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': 'The 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': 'The 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': {},
                                        'types': {'factor': 'double'}}],
                          '__isub__': [{'argInfo': {'right': {'doc': 'Matrix to add to this one.',
                                                              'type': 'MMatrix'}},
                                        'args': [('right', 'MMatrix', 'in')],
                                        'defaults': {},
                                        'deprecated': False,
                                        'doc': 'The 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': 'The 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': 'The 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': {},
                                       'types': {'factor': 'double'}}],
                          '__ne__': [{'argInfo': {'other': {'doc': 'Matrix to compare against.',
                                                            'type': 'MMatrix'}},
                                      'args': [('other', 'MMatrix', 'in')],
                                      'defaults': {},
                                      'deprecated': False,
                                      'doc': 'The 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': 'The 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': 'Compute and return the adjoint of this instance.',
                                       'inArgs': [],
                                       'outArgs': [],
                                       'returnInfo': {'doc': 'The adjoint of this matrix',
                                                      'qualifiers': [],
                                                      'type': 'MMatrix'},
                                       'returnType': 'MMatrix',
                                       'static': False,
                                       'typeQualifiers': {},
                                       'types': {}}],
                          'className': [{'argInfo': {},
                                         'args': [],
                                         'defaults': {},
                                         'deprecated': False,
                                         'doc': 'Returns the name of this class.',
                                         'inArgs': [],
                                         'outArgs': [],
                                         'returnInfo': {'doc': 'The name of this class.',
                                                        'qualifiers': ['*'],
                                                        'type': 'char'},
                                         'returnType': 'char',
                                         'static': True,
                                         'typeQualifiers': {},
                                         'types': {}}],
                          'det3x3': [{'argInfo': {},
                                      'args': [],
                                      'defaults': {},
                                      'deprecated': False,
                                      'doc': 'Compute and return the determinant of the upper left 3x3 submatrix of this instance',
                                      'inArgs': [],
                                      'outArgs': [],
                                      'returnInfo': {'doc': 'The determinant',
                                                     'qualifiers': [],
                                                     'type': 'double'},
                                      'returnType': 'double',
                                      'static': False,
                                      'typeQualifiers': {},
                                      'types': {}}],
                          'det4x4': [{'argInfo': {},
                                      'args': [],
                                      'defaults': {},
                                      'deprecated': False,
                                      'doc': 'Compute and return the determinant of this instance',
                                      'inArgs': [],
                                      'outArgs': [],
                                      'returnInfo': {'doc': 'The determinant',
                                                     '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': 'Fill a 4x4 matrix of doubles with the elements from the instance.',
                                   'inArgs': [],
                                   'outArgs': ['dest'],
                                   'returnInfo': {'doc': '',
                                                  'qualifiers': [],
                                                  'type': None},
                                   'returnType': None,
                                   'static': False,
                                   'typeQualifiers': {},
                                   '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': 'Fill a 4x4 matrix of floats with the elements from the instance.',
                                   'inArgs': [],
                                   'outArgs': ['dest'],
                                   'returnInfo': {'doc': '',
                                                  'qualifiers': [],
                                                  'type': None},
                                   'returnType': None,
                                   'static': False,
                                   'typeQualifiers': {},
                                   'types': {'dest': 'float__array4'}}],
                          'homogenize': [{'argInfo': {},
                                          'args': [],
                                          'defaults': {},
                                          'deprecated': False,
                                          'doc': 'Compute and return a homogenized version of this instance.',
                                          'inArgs': [],
                                          'outArgs': [],
                                          'returnInfo': {'doc': 'The homogenized matrix',
                                                         'qualifiers': [],
                                                         'type': 'MMatrix'},
                                          'returnType': 'MMatrix',
                                          'static': False,
                                          'typeQualifiers': {},
                                          'types': {}}],
                          'inverse': [{'argInfo': {},
                                       'args': [],
                                       'defaults': {},
                                       'deprecated': False,
                                       'doc': 'Compute 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': 'Determine 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',
                                                                         '&']},
                                            'types': {'other': 'MMatrix',
                                                      'tolerance': 'double'}}],
                          'isSingular': [{'argInfo': {},
                                          'args': [],
                                          'defaults': {},
                                          'deprecated': False,
                                          'doc': 'Determines if the given matrix is singular.',
                                          'inArgs': [],
                                          'outArgs': [],
                                          'returnInfo': {'doc': 'True if the matrix is singular and false otherwise',
                                                         'qualifiers': [],
                                                         'type': 'bool'},
                                          'returnType': 'bool',
                                          'static': False,
                                          'typeQualifiers': {},
                                          'types': {}}],
                          'setToIdentity': [{'argInfo': {},
                                             'args': [],
                                             'defaults': {},
                                             'deprecated': False,
                                             'doc': 'Set 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': 'Set 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': 'Compute 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': {}, 'methods': {}, 'pymelEnums': {}},
  'MMeshIntersector': {'enums': {}, 'methods': {}, '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})"}},
                         'methods': {},
                         '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)"}},
  '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': {},
               'pymelEnums': {'Action': "Enum('Action', [('defaultAction', 0), ('kDefaultAction', 0), ('doNotDoAction', 1), ('kDoNotDoAction', 1), ('doAction', 2), ('kDoAction', 2)], multiKeys=True)"}},
  'MModelMessage': {'enums': {'Message': {'valueDocs': {'kActiveListModified': 'active selection changes'},
                                          'values': "Enum('Message', {'kActiveListModified': 0})"}},
                    'methods': {},
                    'pymelEnums': {'Message': "Enum('Message', {'kActiveListModified': 0})"}},
  'MNamespace': {'enums': {}, 'methods': {}, 'pymelEnums': {}},
  'MNodeCacheDisablingInfo': {'enums': {}, 'methods': {}, 'pymelEnums': {}},
  'MNodeCacheDisablingInfoHelper': {'enums': {'ConnectionTestFlag': {'valueDocs': {'kLastConnectionTest': 'Last value, used for counting.',
                                                                                   'kTestDefaultValue': 'Value used by default for the tests.',
                                                                                   'kTestDirtyPlug': 'Do not perform an additional test; the attribute is considered animated if part of the dirty plug list.',
                                                                                   'kTestHierarchy': "Test whether the plug or any of its parents has a connection; if they don't the attribute is not considered animated.",
                                                                                   'kTestPlug': "Test whether the plug has a connection; if it doesn't the attribute is not considered animated.",
                                                                                   'lastConnectionTest': 'Last value, used for counting.',
                                                                                   'testDefaultValue': 'Value used by default for the tests.',
                                                                                   'testDirtyPlug': 'Do not perform an additional test; the attribute is considered animated if part of the dirty plug list.',
                                                                                   'testHierarchy': "Test whether the plug or any of its parents has a connection; if they don't the attribute is not considered animated.",
                                                                                   'testPlug': "Test whether the plug has a connection; if it doesn't the attribute is not considered animated."},
                                                                     'values': "Enum('ConnectionTestFlag', [('kTestDirtyPlug', 0), ('kTestDefaultValue', 0), ('kTestHierarchy', 1), ('kTestPlug', 2), ('kLastConnectionTest', 3)], multiKeys=True)"}},
                                    'methods': {},
                                    'pymelEnums': {'ConnectionTestFlag': "Enum('ConnectionTestFlag', [('testDirtyPlug', 0), ('kTestDefaultValue', 0), ('kTestDirtyPlug', 0), ('testDefaultValue', 0), ('testHierarchy', 1), ('kTestHierarchy', 1), ('testPlug', 2), ('kTestPlug', 2), ('lastConnectionTest', 3), ('kLastConnectionTest', 3)], multiKeys=True)"}},
  'MNodeCacheSetupInfo': {'enums': {'PreferenceFlag': {'valueDocs': {'kLastPreference': 'Last value, used for counting.',
                                                                     'kWantToCacheByDefault': 'Whether or not this node wants to be cached in Evaluation Cache by default.',
                                                                     'lastPreference': 'Last value, used for counting.',
                                                                     'wantToCacheByDefault': 'Whether or not this node wants to be cached in Evaluation Cache by default.'},
                                                       'values': "Enum('PreferenceFlag', {'kWantToCacheByDefault': 0, 'kLastPreference': 1})"},
                                    'RequirementFlag': {'valueDocs': {'kLastRequirement': 'Last value, used for counting.',
                                                                      'kSimulationSupport': 'Whether or not this node requires simulation support, i.e. handling restart time and the such.',
                                                                      'lastRequirement': 'Last value, used for counting.',
                                                                      'simulationSupport': 'Whether or not this node requires simulation support, i.e. handling restart time and the such.'},
                                                        'values': "Enum('RequirementFlag', {'kSimulationSupport': 0, 'kLastRequirement': 1})"}},
                          'methods': {},
                          'pymelEnums': {'PreferenceFlag': "Enum('PreferenceFlag', [('wantToCacheByDefault', 0), ('kWantToCacheByDefault', 0), ('lastPreference', 1), ('kLastPreference', 1)], multiKeys=True)",
                                         'RequirementFlag': "Enum('RequirementFlag', [('simulationSupport', 0), ('kSimulationSupport', 0), ('lastRequirement', 1), ('kLastRequirement', 1)], multiKeys=True)"}},
  'MNodeClass': {'enums': {}, 'methods': {}, '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': {},
                                                  'values': "Enum('KeyableChangeMsg', {'kKeyChangeInvalid': 0, 'kMakeKeyable': 1, 'kMakeUnkeyable': 2, 'kKeyChangeLast': 3})"}},
                   'methods': {},
                   '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': {}, 'pymelEnums': {}},
  'MObject': {'enums': {}, 'methods': {}, 'pymelEnums': {}},
  'MObjectArray': {'enums': {}, 'methods': {}, 'pymelEnums': {}},
  'MObjectHandle': {'enums': {}, 'methods': {}, '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})"}},
                        'methods': {},
                        '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)"}},
  'MObjectSetMessage': {'enums': {}, 'methods': {}, 'pymelEnums': {}},
  'MPaintMessage': {'enums': {}, 'methods': {}, 'pymelEnums': {}},
  'MPanelCanvasInfo': {'enums': {}, 'methods': {}, 'pymelEnums': {}},
  'MParentingEdit': {'enums': {}, 'methods': {}, 'pymelEnums': {}},
  'MPlane': {'enums': {}, 'methods': {}, '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': {'__eq__': [{'argInfo': {'other': {'doc': 'Other plug to compare against',
                                                          'type': 'MPlug'}},
                                    'args': [('other', 'MPlug', 'in')],
                                    'defaults': {},
                                    'deprecated': False,
                                    'doc': 'Comparison 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': "Comparison 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': 'This 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'}}],
                        '__ne__': [{'argInfo': {'other': {'doc': 'Other plug to compare against',
                                                          'type': 'MPlug'}},
                                    'args': [('other', 'MPlug', 'in')],
                                    'defaults': {},
                                    'deprecated': False,
                                    'doc': 'The 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': "The 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': 'Returns 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': {},
                                   'types': {}}],
                        'asBool': [{'argInfo': {},
                                    'args': [],
                                    'defaults': {},
                                    'deprecated': False,
                                    'doc': 'Retrieve 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': {},
                                    'types': {}},
                                   {'argInfo': {'ctx': {'doc': 'Context in which to evaluate the plug',
                                                        'type': 'MDGContext'}},
                                    'args': [('ctx', 'MDGContext', 'in')],
                                    'defaults': {},
                                    'deprecated': True,
                                    'doc': 'This method is obsolete. [as of Maya 2018]',
                                    'inArgs': ['ctx'],
                                    'outArgs': [],
                                    'returnInfo': {'doc': 'Value of plug as a bool',
                                                   'qualifiers': [],
                                                   'type': 'bool'},
                                    'returnType': 'bool',
                                    'static': False,
                                    'typeQualifiers': {'ctx': ['const', '&']},
                                    'types': {'ctx': 'MDGContext'}}],
                        'asChar': [{'argInfo': {},
                                    'args': [],
                                    'defaults': {},
                                    'deprecated': False,
                                    'doc': 'Retrieve 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': {},
                                    'types': {}},
                                   {'argInfo': {'ctx': {'doc': 'Context in which to evaluate the plug',
                                                        'type': 'MDGContext'}},
                                    'args': [('ctx', 'MDGContext', 'in')],
                                    'defaults': {},
                                    'deprecated': True,
                                    'doc': 'This method is obsolete. [as of Maya 2018]',
                                    'inArgs': ['ctx'],
                                    'outArgs': [],
                                    'returnInfo': {'doc': 'Value of plug as a char',
                                                   'qualifiers': [],
                                                   'type': 'char'},
                                    'returnType': 'char',
                                    'static': False,
                                    'typeQualifiers': {'ctx': ['const', '&']},
                                    'types': {'ctx': 'MDGContext'}}],
                        'asDouble': [{'argInfo': {},
                                      'args': [],
                                      'defaults': {},
                                      'deprecated': False,
                                      'doc': 'Retrieve 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': {},
                                      'types': {}},
                                     {'argInfo': {'ctx': {'doc': 'Context in which to evaluate the plug',
                                                          'type': 'MDGContext'}},
                                      'args': [('ctx', 'MDGContext', 'in')],
                                      'defaults': {},
                                      'deprecated': True,
                                      'doc': 'This method is obsolete. [as of Maya 2018]',
                                      'inArgs': ['ctx'],
                                      'outArgs': [],
                                      'returnInfo': {'doc': 'Value of plug as a double',
                                                     'qualifiers': [],
                                                     'type': 'double'},
                                      'returnType': 'double',
                                      'static': False,
                                      'typeQualifiers': {'ctx': ['const', '&']},
                                      'types': {'ctx': 'MDGContext'}}],
                        'asFloat': [{'argInfo': {},
                                     'args': [],
                                     'defaults': {},
                                     'deprecated': False,
                                     'doc': 'Retrieve 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': {},
                                     'types': {}},
                                    {'argInfo': {'ctx': {'doc': 'Context in which to evaluate the plug',
                                                         'type': 'MDGContext'}},
                                     'args': [('ctx', 'MDGContext', 'in')],
                                     'defaults': {},
                                     'deprecated': True,
                                     'doc': 'This method is obsolete. [as of Maya 2018]',
                                     'inArgs': ['ctx'],
                                     'outArgs': [],
                                     'returnInfo': {'doc': 'Value of plug as a float',
                                                    'qualifiers': [],
                                                    'type': 'float'},
                                     'returnType': 'float',
                                     'static': False,
                                     'typeQualifiers': {'ctx': ['const', '&']},
                                     'types': {'ctx': 'MDGContext'}}],
                        'asInt': [{'argInfo': {},
                                   'args': [],
                                   'defaults': {},
                                   'deprecated': False,
                                   'doc': 'Retrieve 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': {},
                                   'types': {}},
                                  {'argInfo': {'ctx': {'doc': 'Context in which to evaluate the plug',
                                                       'type': 'MDGContext'}},
                                   'args': [('ctx', 'MDGContext', 'in')],
                                   'defaults': {},
                                   'deprecated': True,
                                   'doc': 'This method is obsolete. [as of Maya 2018]',
                                   'inArgs': ['ctx'],
                                   'outArgs': [],
                                   'returnInfo': {'doc': 'Value of plug as an int',
                                                  'qualifiers': [],
                                                  'type': 'int'},
                                   'returnType': 'int',
                                   'static': False,
                                   'typeQualifiers': {'ctx': ['const', '&']},
                                   'types': {'ctx': 'MDGContext'}}],
                        'asInt64': [{'argInfo': {},
                                     'args': [],
                                     'defaults': {},
                                     'deprecated': False,
                                     'doc': 'Retrieve 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': {},
                                     'types': {}},
                                    {'argInfo': {'ctx': {'doc': 'Context in which to evaluate the plug',
                                                         'type': 'MDGContext'}},
                                     'args': [('ctx', 'MDGContext', 'in')],
                                     'defaults': {},
                                     'deprecated': True,
                                     'doc': 'This method is obsolete. [as of Maya 2018]',
                                     'inArgs': ['ctx'],
                                     'outArgs': [],
                                     'returnInfo': {'doc': 'Value of plug as an int',
                                                    'qualifiers': [],
                                                    'type': 'MInt64'},
                                     'returnType': 'MInt64',
                                     'static': False,
                                     'typeQualifiers': {'ctx': ['const', '&']},
                                     'types': {'ctx': 'MDGContext'}}],
                        'asMAngle': [{'argInfo': {},
                                      'args': [],
                                      'defaults': {},
                                      'deprecated': False,
                                      'doc': 'Retrieve 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': {},
                                      'types': {}},
                                     {'argInfo': {'ctx': {'doc': 'Context in which to evaluate the plug',
                                                          'type': 'MDGContext'}},
                                      'args': [('ctx', 'MDGContext', 'in')],
                                      'defaults': {},
                                      'deprecated': True,
                                      'doc': 'This method is obsolete. [as of Maya 2018]',
                                      'inArgs': ['ctx'],
                                      'outArgs': [],
                                      'returnInfo': {'doc': 'Value of plug as an MAngle',
                                                     'qualifiers': [],
                                                     'type': 'MAngle'},
                                      'returnType': 'MAngle',
                                      'static': False,
                                      'typeQualifiers': {'ctx': ['const', '&']},
                                      'types': {'ctx': 'MDGContext'}}],
                        'asMDataHandle': [{'argInfo': {},
                                           'args': [],
                                           'defaults': {},
                                           'deprecated': False,
                                           'doc': 'Retrieve 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': {},
                                           'types': {}},
                                          {'argInfo': {'ctx': {'doc': 'Context in which to evaluate the plug',
                                                               'type': 'MDGContext'}},
                                           'args': [('ctx',
                                                     'MDGContext',
                                                     'in')],
                                           'defaults': {},
                                           'deprecated': True,
                                           'doc': 'This method is obsolete. [as of Maya 2018]',
                                           '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': {'ctx': ['const',
                                                                      '&']},
                                           'types': {'ctx': 'MDGContext'}}],
                        'asMDistance': [{'argInfo': {},
                                         'args': [],
                                         'defaults': {},
                                         'deprecated': False,
                                         'doc': 'Retrieve 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': {},
                                         'types': {}},
                                        {'argInfo': {'ctx': {'doc': 'Context in which to evaluate the plug',
                                                             'type': 'MDGContext'}},
                                         'args': [('ctx', 'MDGContext', 'in')],
                                         'defaults': {},
                                         'deprecated': True,
                                         'doc': 'This method is obsolete. [as of Maya 2018]',
                                         'inArgs': ['ctx'],
                                         'outArgs': [],
                                         'returnInfo': {'doc': 'Value of plug as an MDistance',
                                                        'qualifiers': [],
                                                        'type': 'MDistance'},
                                         'returnType': 'MDistance',
                                         'static': False,
                                         'typeQualifiers': {'ctx': ['const',
                                                                    '&']},
                                         'types': {'ctx': 'MDGContext'}}],
                        'asMObject': [{'argInfo': {},
                                       'args': [],
                                       'defaults': {},
                                       'deprecated': False,
                                       'doc': 'Retrieve 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': {},
                                       'types': {}},
                                      {'argInfo': {'ctx': {'doc': 'Context in which to evaluate the plug',
                                                           'type': 'MDGContext'}},
                                       'args': [('ctx', 'MDGContext', 'in')],
                                       'defaults': {},
                                       'deprecated': True,
                                       'doc': 'This method is obsolete. [as of Maya 2018]',
                                       'inArgs': ['ctx'],
                                       'outArgs': [],
                                       'returnInfo': {'doc': 'Value of plug as an MObject',
                                                      'qualifiers': [],
                                                      'type': 'MObject'},
                                       'returnType': 'MObject',
                                       'static': False,
                                       'typeQualifiers': {'ctx': ['const',
                                                                  '&']},
                                       'types': {'ctx': 'MDGContext'}}],
                        'asMTime': [{'argInfo': {},
                                     'args': [],
                                     'defaults': {},
                                     'deprecated': False,
                                     'doc': 'Retrieve 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': {},
                                     'types': {}},
                                    {'argInfo': {'ctx': {'doc': 'Context in which to evaluate the plug',
                                                         'type': 'MDGContext'}},
                                     'args': [('ctx', 'MDGContext', 'in')],
                                     'defaults': {},
                                     'deprecated': True,
                                     'doc': 'This method is obsolete. [as of Maya 2018]',
                                     'inArgs': ['ctx'],
                                     'outArgs': [],
                                     'returnInfo': {'doc': 'Value of plug as an MTime',
                                                    'qualifiers': [],
                                                    'type': 'MTime'},
                                     'returnType': 'MTime',
                                     'static': False,
                                     'typeQualifiers': {'ctx': ['const', '&']},
                                     'types': {'ctx': 'MDGContext'}}],
                        'asShort': [{'argInfo': {},
                                     'args': [],
                                     'defaults': {},
                                     'deprecated': False,
                                     'doc': 'Retrieve 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': {},
                                     'types': {}},
                                    {'argInfo': {'ctx': {'doc': 'Context in which to evaluate the plug',
                                                         'type': 'MDGContext'}},
                                     'args': [('ctx', 'MDGContext', 'in')],
                                     'defaults': {},
                                     'deprecated': True,
                                     'doc': 'This method is obsolete. [as of Maya 2018]',
                                     'inArgs': ['ctx'],
                                     'outArgs': [],
                                     'returnInfo': {'doc': 'Value of plug as a short',
                                                    'qualifiers': [],
                                                    'type': 'short'},
                                     'returnType': 'short',
                                     'static': False,
                                     'typeQualifiers': {'ctx': ['const', '&']},
                                     'types': {'ctx': 'MDGContext'}}],
                        'asString': [{'argInfo': {},
                                      'args': [],
                                      'defaults': {},
                                      'deprecated': False,
                                      'doc': 'Retrieve 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': {},
                                      'types': {}},
                                     {'argInfo': {'ctx': {'doc': 'Context in which to evaluate the plug',
                                                          'type': 'MDGContext'}},
                                      'args': [('ctx', 'MDGContext', 'in')],
                                      'defaults': {},
                                      'deprecated': True,
                                      'doc': 'This method is obsolete. [as of Maya 2018]',
                                      'inArgs': ['ctx'],
                                      'outArgs': [],
                                      'returnInfo': {'doc': 'Value of plug as an MString',
                                                     'qualifiers': [],
                                                     'type': 'MString'},
                                      'returnType': 'MString',
                                      'static': False,
                                      'typeQualifiers': {'ctx': ['const', '&']},
                                      'types': {'ctx': 'MDGContext'}}],
                        'attribute': [{'argInfo': {},
                                       'args': [],
                                       'defaults': {},
                                       'deprecated': False,
                                       'doc': 'This 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': {},
                                       'types': {}}],
                        'child': [{'argInfo': {'obj': {'doc': 'The child attribute.',
                                                       'type': 'MObject'}},
                                   'args': [('obj', 'MObject', 'in')],
                                   'defaults': {},
                                   'deprecated': False,
                                   'doc': 'Returns a plug to a given attribute that is a child of this plug. This method is only valid for compound plugs that are not arrays.',
                                   'inArgs': ['obj'],
                                   'outArgs': [],
                                   'returnInfo': {'doc': 'The child plug',
                                                  'qualifiers': [],
                                                  'type': 'MPlug'},
                                   'returnType': 'MPlug',
                                   'static': False,
                                   'typeQualifiers': {'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': 'Returns a plug to a given attribute that is a child of this plug. This method is only valid for compound plugs that are not arrays.',
                                   'inArgs': ['index'],
                                   'outArgs': [],
                                   'returnInfo': {'doc': 'The child plug',
                                                  'qualifiers': [],
                                                  'type': 'MPlug'},
                                   'returnType': 'MPlug',
                                   'static': False,
                                   'typeQualifiers': {'index': ['unsigned']},
                                   'types': {'index': 'uint'}}],
                        'className': [{'argInfo': {},
                                       'args': [],
                                       'defaults': {},
                                       'deprecated': False,
                                       'doc': 'Returns the name of this class.',
                                       'inArgs': [],
                                       'outArgs': [],
                                       'returnInfo': {'doc': 'Name of this class.',
                                                      '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': 'This 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': {'array': ['&']},
                                         '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': 'This 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': {'index': ['unsigned']},
                                                       'types': {'index': 'uint'}}],
                        'constructHandle': [{'argInfo': {'mBlock': {'doc': '',
                                                                    'type': 'MDataBlock'}},
                                             'args': [('mBlock',
                                                       'MDataBlock',
                                                       'in')],
                                             'defaults': {},
                                             'deprecated': False,
                                             'doc': 'This method returns a data handle constructed for this plug.',
                                             'inArgs': ['mBlock'],
                                             'outArgs': [],
                                             'returnInfo': {'doc': 'MDataHandle for this plug',
                                                            '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': 'If this plug is a source, return the destination plugs connected to it.',
                                          'inArgs': [],
                                          'outArgs': ['theDestinations'],
                                          'returnInfo': {'doc': 'Returns true if the plug has one or more destinations.',
                                                         'qualifiers': [],
                                                         'type': 'bool'},
                                          'returnType': 'bool',
                                          'static': False,
                                          'typeQualifiers': {'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': 'If this plug is a source, return the destination plugs connected to it.',
                                                         'inArgs': [],
                                                         'outArgs': ['theDestinations'],
                                                         'returnInfo': {'doc': 'Returns true if the plug has one or more destinations.',
                                                                        'qualifiers': [],
                                                                        'type': 'bool'},
                                                         'returnType': 'bool',
                                                         'static': False,
                                                         'typeQualifiers': {'theDestinations': ['&']},
                                                         'types': {'theDestinations': 'MPlugArray'}}],
                        'destructHandle': [{'argInfo': {'mHandle': {'doc': '',
                                                                    'type': 'MDataHandle'}},
                                            'args': [('mHandle',
                                                      'MDataHandle',
                                                      'in')],
                                            'defaults': {},
                                            'deprecated': False,
                                            'doc': 'This method destructs the data handle for this plug.',
                                            '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': 'This 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': {'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': 'This 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': {'index': ['unsigned']},
                                                    'types': {'index': 'uint'}}],
                        'evaluateNumElements': [{'argInfo': {},
                                                 'args': [],
                                                 'defaults': {},
                                                 'deprecated': False,
                                                 'doc': 'Return 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': 'uint'},
                                                 'returnType': 'uint',
                                                 'static': False,
                                                 'typeQualifiers': {},
                                                 'types': {}}],
                        'getExistingArrayAttributeIndices': [{'argInfo': {'indices': {'doc': 'A list to store the logical indices of the set/connected elements.',
                                                                                      'type': 'MIntArray'}},
                                                              'args': [('indices',
                                                                        'MIntArray',
                                                                        'out')],
                                                              'defaults': {},
                                                              'deprecated': False,
                                                              'doc': 'This 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': ['indices'],
                                                              'returnInfo': {'doc': 'The number of set/connected elements',
                                                                             'qualifiers': [],
                                                                             'type': 'uint'},
                                                              'returnType': 'uint',
                                                              'static': False,
                                                              'typeQualifiers': {'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': '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. (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': 'Returns 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': ['&']},
                                            'types': {'cmds': 'MStringArray',
                                                      'useLongNames': 'bool',
                                                      'valueSelector': ('MPlug',
                                                                        'MValueSelector')}}],
                        'getValue': [{'argInfo': {'ctx': {'doc': '',
                                                          'type': 'MDGContext'},
                                                  'val': {'doc': '',
                                                          'type': 'MObject'}},
                                      'args': [('val', 'MObject', 'out'),
                                               ('ctx', 'MDGContext', 'in')],
                                      'defaults': {},
                                      'deprecated': True,
                                      'doc': 'This method is obsolete. [as of Maya 2018]',
                                      'inArgs': ['ctx'],
                                      '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': 'This method is obsolete. [as of Maya 2018]',
                                      'inArgs': ['ctx'],
                                      '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': 'This method is obsolete. [as of Maya 2018]',
                                      'inArgs': ['ctx'],
                                      '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': 'This method is obsolete. [as of Maya 2018]',
                                      'inArgs': ['ctx'],
                                      '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': 'This method is obsolete. [as of Maya 2018]',
                                      'inArgs': ['ctx'],
                                      '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': 'This method is obsolete. [as of Maya 2018]',
                                      'inArgs': ['ctx'],
                                      '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': 'This method is obsolete. [as of Maya 2018]',
                                      'inArgs': ['ctx'],
                                      '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': 'This method is obsolete. [as of Maya 2018]',
                                      'inArgs': ['ctx'],
                                      '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': 'This method is obsolete. [as of Maya 2018]',
                                      'inArgs': ['ctx'],
                                      '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': 'This method is obsolete. [as of Maya 2018]',
                                      'inArgs': ['ctx'],
                                      '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': 'This method is obsolete. [as of Maya 2018]',
                                      'inArgs': ['ctx'],
                                      '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': 'This method is obsolete. [as of Maya 2018]',
                                      'inArgs': ['ctx'],
                                      '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': 'This method is obsolete. [as of Maya 2018]',
                                      'inArgs': ['ctx'],
                                      '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': 'This 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': {},
                                  'types': {}}],
                        'isArray': [{'argInfo': {},
                                     'args': [],
                                     'defaults': {},
                                     'deprecated': False,
                                     'doc': 'This 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': {},
                                     'types': {}}],
                        'isCachingFlagSet': [{'argInfo': {},
                                              'args': [],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': 'Returns 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': {},
                                              'types': {}}],
                        'isChannelBoxFlagSet': [{'argInfo': {},
                                                 'args': [],
                                                 'defaults': {},
                                                 'deprecated': False,
                                                 'doc': 'Returns 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': {},
                                                 'types': {}}],
                        'isChild': [{'argInfo': {},
                                     'args': [],
                                     'defaults': {},
                                     'deprecated': False,
                                     'doc': "This 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': {},
                                     'types': {}}],
                        'isCompound': [{'argInfo': {},
                                        'args': [],
                                        'defaults': {},
                                        'deprecated': False,
                                        'doc': 'This 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': {},
                                        'types': {}}],
                        'isConnected': [{'argInfo': {},
                                         'args': [],
                                         'defaults': {},
                                         'deprecated': False,
                                         'doc': 'Determines 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': {},
                                         'types': {}}],
                        'isDefaultValue': [{'argInfo': {'forceEval': {'doc': 'Evaluate the plug prior to test.',
                                                                      'type': 'bool'}},
                                            'args': [('forceEval',
                                                      'bool',
                                                      'in')],
                                            'defaults': {'forceEval': True},
                                            'deprecated': False,
                                            'doc': "This 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': {},
                                            'types': {'forceEval': 'bool'}}],
                        'isDestination': [{'argInfo': {},
                                           'args': [],
                                           'defaults': {},
                                           'deprecated': False,
                                           'doc': 'Determines 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': {},
                                           'types': {}}],
                        'isDynamic': [{'argInfo': {},
                                       'args': [],
                                       'defaults': {},
                                       'deprecated': False,
                                       'doc': 'Determines 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': {},
                                       'types': {}}],
                        'isElement': [{'argInfo': {},
                                       'args': [],
                                       'defaults': {},
                                       'deprecated': False,
                                       'doc': 'This 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': {},
                                       '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': "Returns 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': {},
                                            'types': {'checkChildren': 'bool',
                                                      'checkParents': 'bool'}}],
                        'isFromReferencedFile': [{'argInfo': {},
                                                  'args': [],
                                                  'defaults': {},
                                                  'deprecated': False,
                                                  'doc': 'This 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': {},
                                                  'types': {}}],
                        'isIgnoredWhenRendering': [{'argInfo': {},
                                                    'args': [],
                                                    'defaults': {},
                                                    'deprecated': False,
                                                    'doc': 'Determines 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': {},
                                                    'types': {}}],
                        'isKeyable': [{'argInfo': {},
                                       'args': [],
                                       'defaults': {},
                                       'deprecated': False,
                                       'doc': 'Determines 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': {},
                                       'types': {}}],
                        'isLocked': [{'argInfo': {},
                                      'args': [],
                                      'defaults': {},
                                      'deprecated': False,
                                      'doc': "Determines 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': {},
                                      'types': {}}],
                        'isNetworked': [{'argInfo': {},
                                         'args': [],
                                         'defaults': {},
                                         'deprecated': False,
                                         'doc': 'This method determines if the plug is networked or non-networked.',
                                         'inArgs': [],
                                         'outArgs': [],
                                         'returnInfo': {'doc': 'true false',
                                                        'qualifiers': [],
                                                        'type': 'bool'},
                                         'returnType': 'bool',
                                         'static': False,
                                         'typeQualifiers': {},
                                         'types': {}}],
                        'isNull': [{'argInfo': {},
                                    'args': [],
                                    'defaults': {},
                                    'deprecated': False,
                                    'doc': 'This 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': {},
                                    'types': {}}],
                        'isProcedural': [{'argInfo': {},
                                          'args': [],
                                          'defaults': {},
                                          'deprecated': False,
                                          'doc': "This 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': {},
                                          'types': {}}],
                        'isSource': [{'argInfo': {},
                                      'args': [],
                                      'defaults': {},
                                      'deprecated': False,
                                      'doc': 'Determines 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': {},
                                      'types': {}}],
                        'logicalIndex': [{'argInfo': {},
                                          'args': [],
                                          'defaults': {},
                                          'deprecated': False,
                                          'doc': 'Returns 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': 'uint'},
                                          'returnType': 'uint',
                                          'static': False,
                                          'typeQualifiers': {},
                                          'types': {}}],
                        'name': [{'argInfo': {},
                                  'args': [],
                                  'defaults': {},
                                  'deprecated': False,
                                  'doc': "Returns 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': {},
                                  'types': {}}],
                        'node': [{'argInfo': {},
                                  'args': [],
                                  'defaults': {},
                                  'deprecated': False,
                                  'doc': 'Returns 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': {},
                                  'types': {}}],
                        'numChildren': [{'argInfo': {},
                                         'args': [],
                                         'defaults': {},
                                         'deprecated': False,
                                         'doc': 'Return the total number of children of this compound plug.',
                                         'inArgs': [],
                                         'outArgs': [],
                                         'returnInfo': {'doc': 'Total number of children',
                                                        'qualifiers': [],
                                                        'type': 'uint'},
                                         'returnType': 'uint',
                                         'static': False,
                                         'typeQualifiers': {},
                                         'types': {}}],
                        'numConnectedChildren': [{'argInfo': {},
                                                  'args': [],
                                                  'defaults': {},
                                                  'deprecated': False,
                                                  'doc': 'Return the number of children of this plug that are connected in the dependency graph.',
                                                  'inArgs': [],
                                                  'outArgs': [],
                                                  'returnInfo': {'doc': 'Total number of children',
                                                                 'qualifiers': [],
                                                                 'type': 'uint'},
                                                  'returnType': 'uint',
                                                  'static': False,
                                                  'typeQualifiers': {},
                                                  'types': {}}],
                        'numConnectedElements': [{'argInfo': {},
                                                  'args': [],
                                                  'defaults': {},
                                                  'deprecated': False,
                                                  'doc': 'Return the total number of connected element plugs belonging to this array plug.',
                                                  'inArgs': [],
                                                  'outArgs': [],
                                                  'returnInfo': {'doc': 'Total number of elements',
                                                                 'qualifiers': [],
                                                                 'type': 'uint'},
                                                  'returnType': 'uint',
                                                  'static': False,
                                                  'typeQualifiers': {},
                                                  'types': {}}],
                        'numElements': [{'argInfo': {},
                                         'args': [],
                                         'defaults': {},
                                         'deprecated': False,
                                         'doc': 'Return 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': 'uint'},
                                         'returnType': 'uint',
                                         'static': False,
                                         'typeQualifiers': {},
                                         'types': {}}],
                        'parent': [{'argInfo': {},
                                    'args': [],
                                    'defaults': {},
                                    'deprecated': False,
                                    'doc': 'Returns 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': {},
                                    '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. If the attribute is marked as indexMatters then its array index will be included regardless of the setting of this parameter. 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': 'By 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': {},
                                         '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': "This 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': 'This 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': 'Set the current value of the attribute this plug references.',
                                     'inArgs': ['val'],
                                     'outArgs': [],
                                     'returnInfo': {'doc': '',
                                                    'qualifiers': [],
                                                    'type': None},
                                     'returnType': None,
                                     'static': False,
                                     'typeQualifiers': {},
                                     'types': {'val': 'bool'}}],
                        'setCaching': [{'argInfo': {'isCaching': {'doc': 'True if this plug should be cached',
                                                                  'type': 'bool'}},
                                        'args': [('isCaching', 'bool', 'in')],
                                        'defaults': {},
                                        'deprecated': False,
                                        'doc': 'Sets 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': {},
                                        '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': 'Sets 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': {},
                                           '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': 'Set the current value of the attribute this plug references.',
                                     'inArgs': ['val'],
                                     'outArgs': [],
                                     'returnInfo': {'doc': '',
                                                    'qualifiers': [],
                                                    'type': None},
                                     'returnType': None,
                                     'static': False,
                                     'typeQualifiers': {},
                                     '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': 'Set the current value of the attribute this plug references.',
                                       'inArgs': ['val'],
                                       'outArgs': [],
                                       'returnInfo': {'doc': '',
                                                      'qualifiers': [],
                                                      'type': None},
                                       'returnType': None,
                                       'static': False,
                                       'typeQualifiers': {},
                                       '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': 'Set the current value of the attribute this plug references.',
                                      'inArgs': ['val'],
                                      'outArgs': [],
                                      'returnInfo': {'doc': '',
                                                     'qualifiers': [],
                                                     'type': None},
                                      'returnType': None,
                                      'static': False,
                                      'typeQualifiers': {},
                                      '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': 'Set the current value of the attribute this plug references.',
                                    'inArgs': ['val'],
                                    'outArgs': [],
                                    'returnInfo': {'doc': '',
                                                   'qualifiers': [],
                                                   'type': None},
                                    'returnType': None,
                                    'static': False,
                                    'typeQualifiers': {},
                                    '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': 'Set the current value of the attribute this plug references.',
                                      'inArgs': ['val'],
                                      'outArgs': [],
                                      'returnInfo': {'doc': '',
                                                     'qualifiers': [],
                                                     'type': None},
                                      'returnType': None,
                                      'static': False,
                                      'typeQualifiers': {},
                                      'types': {'val': 'MInt64'}}],
                        'setKeyable': [{'argInfo': {'keyable': {'doc': 'True if this plug should be keyable',
                                                                'type': 'bool'}},
                                        'args': [('keyable', 'bool', 'in')],
                                        'defaults': {},
                                        'deprecated': False,
                                        'doc': 'This 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': {},
                                        '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': "Sets 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': {},
                                       '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': 'Set 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': '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': "Set 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': ['const',
                                                                          '&']},
                                            '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': 'Set 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': 'MDistance'}}],
                        'setMObject': [{'argInfo': {'val': {'doc': 'The value to which the attribute will be set',
                                                            'type': 'MObject'}},
                                        'args': [('val', 'MObject', 'in')],
                                        'defaults': {},
                                        'deprecated': False,
                                        'doc': 'Set 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': 'MObject'}}],
                        'setMPxData': [{'argInfo': {'val': {'doc': 'The value to which the attribute will be set',
                                                            'type': 'MPxData'}},
                                        'args': [('val', 'MPxData', 'in')],
                                        'defaults': {},
                                        'deprecated': False,
                                        'doc': 'Set 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': 'MPxData'}}],
                        'setMTime': [{'argInfo': {'val': {'doc': 'The value to which the attribute will be set',
                                                          'type': 'MTime'}},
                                      'args': [('val', 'MTime', 'in')],
                                      'defaults': {},
                                      'deprecated': False,
                                      'doc': 'Set 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': 'MTime'}}],
                        'setNumElements': [{'argInfo': {'elements': {'doc': 'new array size',
                                                                     'type': 'uint'}},
                                            'args': [('elements',
                                                      'uint',
                                                      'in')],
                                            'defaults': {},
                                            'deprecated': False,
                                            'doc': 'The 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': 'Set the current value of the attribute this plug references.',
                                      'inArgs': ['val'],
                                      'outArgs': [],
                                      'returnInfo': {'doc': '',
                                                     'qualifiers': [],
                                                     'type': None},
                                      'returnType': None,
                                      'static': False,
                                      'typeQualifiers': {},
                                      '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': 'Set 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'}}],
                        'source': [{'argInfo': {},
                                    'args': [],
                                    'defaults': {},
                                    'deprecated': False,
                                    'doc': 'If 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': {},
                                    'types': {}}],
                        'sourceWithConversion': [{'argInfo': {},
                                                  'args': [],
                                                  'defaults': {},
                                                  'deprecated': False,
                                                  'doc': 'If 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': {},
                                                  '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': {}, 'methods': {}, 'pymelEnums': {}},
  'MPoint': {'enums': {},
             'methods': {'__add__': [{'argInfo': {'other': {'doc': 'Vector to add.',
                                                            'type': 'MVector'}},
                                      'args': [('other', 'MVector', 'in')],
                                      'defaults': {},
                                      'deprecated': False,
                                      'doc': 'The 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'}}],
                         '__eq__': [{'argInfo': {'other': {'doc': 'Point to compare with.',
                                                           'type': 'MPoint'}},
                                     'args': [('other', 'MPoint', 'in')],
                                     'defaults': {},
                                     'deprecated': False,
                                     'doc': 'The 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': 'The index operator.',
                                          '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': 'The 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': 'The 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': 'The 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': 'The 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': 'The 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': 'The 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': 'The 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': 'The 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': 'The 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': 'The 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': 'The 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': 'The 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': 'The 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': 'The 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': 'The 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': 'The 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'}}],
                         '__ne__': [{'argInfo': {'other': {'doc': 'Point to compare with.',
                                                           'type': 'MPoint'}},
                                     'args': [('other', 'MPoint', 'in')],
                                     'defaults': {},
                                     'deprecated': False,
                                     'doc': 'The 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': 'The 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': 'The 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'}}],
                         '__truediv__': [{'argInfo': {'scale': {'doc': 'The scale parameter.',
                                                                'type': 'double'}},
                                          'args': [('scale', 'double', 'in')],
                                          'defaults': {},
                                          'deprecated': False,
                                          'doc': 'The 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'}}],
                         'cartesianize': [{'argInfo': {},
                                           'args': [],
                                           'defaults': {},
                                           'deprecated': False,
                                           'doc': 'If 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.',
                                           'inArgs': [],
                                           'outArgs': [],
                                           'returnInfo': {'doc': '',
                                                          'qualifiers': ['&'],
                                                          'type': 'MPoint'},
                                           'returnType': 'MPoint',
                                           'static': False,
                                           'typeQualifiers': {},
                                           'types': {}}],
                         'className': [{'argInfo': {},
                                        'args': [],
                                        'defaults': {},
                                        'deprecated': False,
                                        'doc': 'Returns the name of this class.',
                                        'inArgs': [],
                                        'outArgs': [],
                                        'returnInfo': {'doc': 'The name of this class.',
                                                       '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': 'Return 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': 'Copy 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': {},
                                  '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': 'Copy 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': {},
                                  'types': {'dest': 'float__array4'}}],
                         'homogenize': [{'argInfo': {},
                                         'args': [],
                                         'defaults': {},
                                         'deprecated': False,
                                         'doc': 'If 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).',
                                         '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': 'Returns 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',
                                                                        '&']},
                                           'types': {'other': 'MPoint',
                                                     'tol': 'double'}}],
                         'rationalize': [{'argInfo': {},
                                          'args': [],
                                          'defaults': {},
                                          'deprecated': False,
                                          'doc': 'If 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.',
                                          'inArgs': [],
                                          'outArgs': [],
                                          'returnInfo': {'doc': '',
                                                         'qualifiers': ['&'],
                                                         'type': 'MPoint'},
                                          'returnType': 'MPoint',
                                          'static': False,
                                          'typeQualifiers': {},
                                          'types': {}}]},
             'pymelEnums': {}},
  'MPointArray': {'enums': {}, 'methods': {}, 'pymelEnums': {}},
  'MPointOnMesh': {'enums': {}, 'methods': {}, 'pymelEnums': {}},
  'MPointOnNurbs': {'enums': {}, 'methods': {}, 'pymelEnums': {}},
  'MPolyMessage': {'constants': {'kEdgeIndex': 1,
                                 'kFaceIndex': 2,
                                 'kLastErrorIndex': 3,
                                 'kVertexIndex': 0},
                   'enums': {'ColorSetMessageType': {'valueDocs': {'colorSetAdded': 'new Color set added',
                                                                   'colorSetDeleted': 'Color set deleted.',
                                                                   'currentColorSetChanged': 'current Color set changed',
                                                                   'kColorSetAdded': 'new Color set added',
                                                                   'kColorSetDeleted': 'Color set deleted.',
                                                                   'kCurrentColorSetChanged': 'current Color set changed'},
                                                     'values': "Enum('ColorSetMessageType', {'kColorSetAdded': 0, 'kColorSetDeleted': 1, 'kCurrentColorSetChanged': 2})"},
                             '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': {},
                   'pymelEnums': {'ColorSetMessageType': "Enum('ColorSetMessageType', [('colorSetAdded', 0), ('kColorSetAdded', 0), ('colorSetDeleted', 1), ('kColorSetDeleted', 1), ('currentColorSetChanged', 2), ('kCurrentColorSetChanged', 2)], multiKeys=True)",
                                  'MessageType': "Enum('MessageType', [('UVSetAdded', 0), ('kUVSetAdded', 0), ('UVSetDeleted', 1), ('kUVSetDeleted', 1), ('currentUVSetChanged', 2), ('kCurrentUVSetChanged', 2)], multiKeys=True)"}},
  'MProfiler': {'enums': {'ProfilingColor': {'valueDocs': {},
                                             'values': "Enum('ProfilingColor', {'kColorA_L1': 0, 'kColorA_L2': 1, 'kColorA_L3': 2, 'kColorB_L1': 3, 'kColorB_L2': 4, 'kColorB_L3': 5, 'kColorC_L1': 6, 'kColorC_L2': 7, 'kColorC_L3': 8, 'kColorD_L1': 9, 'kColorD_L2': 10, 'kColorD_L3': 11, 'kColorE_L1': 12, 'kColorE_L2': 13, 'kColorE_L3': 14, 'kColorG_L1': 15, 'kColorG_L2': 16, 'kColorG_L3': 17, 'kColorCount': 18})"}},
                'methods': {},
                'pymelEnums': {'ProfilingColor': "Enum('ProfilingColor', [('A_L1', 0), ('kColorA_L1', 0), ('A_L2', 1), ('kColorA_L2', 1), ('A_L3', 2), ('kColorA_L3', 2), ('B_L1', 3), ('kColorB_L1', 3), ('B_L2', 4), ('kColorB_L2', 4), ('B_L3', 5), ('kColorB_L3', 5), ('C_L1', 6), ('kColorC_L1', 6), ('C_L2', 7), ('kColorC_L2', 7), ('C_L3', 8), ('kColorC_L3', 8), ('D_L1', 9), ('kColorD_L1', 9), ('D_L2', 10), ('kColorD_L2', 10), ('D_L3', 11), ('kColorD_L3', 11), ('E_L1', 12), ('kColorE_L1', 12), ('E_L2', 13), ('kColorE_L2', 13), ('E_L3', 14), ('kColorE_L3', 14), ('G_L1', 15), ('kColorG_L1', 15), ('G_L2', 16), ('kColorG_L2', 16), ('G_L3', 17), ('kColorG_L3', 17), ('count', 18), ('kColorCount', 18)], multiKeys=True)"}},
  'MProfilingScope': {'enums': {}, 'methods': {}, 'pymelEnums': {}},
  'MProgressWindow': {'enums': {}, 'methods': {}, 'pymelEnums': {}},
  'MQtUtil': {'enums': {}, 'methods': {}, 'pymelEnums': {}},
  'MQuaternion': {'enums': {},
                  'invertibles': [('setAxisAngle', 'getAxisAngle')],
                  'methods': {'__add__': [{'argInfo': {'other': {'doc': 'the quaternion to be added to this quaternion',
                                                                 'type': 'MQuaternion'}},
                                           'args': [('other',
                                                     'MQuaternion',
                                                     'in')],
                                           'defaults': {},
                                           'deprecated': False,
                                           'doc': 'The 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': 'The 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': 'The 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'}}],
                              '__imul__': [{'argInfo': {'other': {'doc': 'the quaternion to be multiplied with this quaternion',
                                                                  'type': 'MQuaternion'}},
                                            'args': [('other',
                                                      'MQuaternion',
                                                      'in')],
                                            'defaults': {},
                                            'deprecated': False,
                                            'doc': 'The 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': 'This 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'}}],
                              '__ne__': [{'argInfo': {'other': {'doc': 'the quaternion to be compared with this quaternion',
                                                                'type': 'MQuaternion'}},
                                          'args': [('other',
                                                    'MQuaternion',
                                                    'in')],
                                          'defaults': {},
                                          'deprecated': False,
                                          'doc': 'The 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': 'The 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': 'The unary minus operator. Negates the value of each of the x, y, z, and w components of the quaternion.',
                                           'inArgs': [],
                                           'outArgs': [],
                                           'returnInfo': {'doc': 'Quaternion that results from the negation',
                                                          'qualifiers': [],
                                                          'type': 'MQuaternion'},
                                           'returnType': 'MQuaternion',
                                           'static': False,
                                           'typeQualifiers': {},
                                           'types': {}}],
                              'asEulerRotation': [{'argInfo': {},
                                                   'args': [],
                                                   'defaults': {},
                                                   'deprecated': False,
                                                   'doc': 'Converts 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': "Converts 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': 'Returns the conjugate of this quaternion. The result is a quaternion whose x, y, and z values have been negated.',
                                             'inArgs': [],
                                             'outArgs': [],
                                             'returnInfo': {'doc': 'Quaternion that is the conjugate of this quaternion',
                                                            'qualifiers': [],
                                                            'type': 'MQuaternion'},
                                             'returnType': 'MQuaternion',
                                             'static': False,
                                             'typeQualifiers': {},
                                             'types': {}}],
                              'conjugateIt': [{'argInfo': {},
                                               'args': [],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': 'Performs 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': 'A reference to the quaternion that has been conjugated',
                                                              'qualifiers': ['&'],
                                                              'type': 'MQuaternion'},
                                               'returnType': 'MQuaternion',
                                               'static': False,
                                               'typeQualifiers': {},
                                               'types': {}}],
                              'exp': [{'argInfo': {},
                                       'args': [],
                                       'defaults': {},
                                       'deprecated': False,
                                       'doc': 'Exponentiates a quaternion that has a scalar part of zero. The precondition for using this method is that w is zero.',
                                       'inArgs': [],
                                       'outArgs': [],
                                       'returnInfo': {'doc': 'Quaternion that is the result of exponentiating this quaternion',
                                                      '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': 'Extracts 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': {},
                                       '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': "Converts 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': 'Returns the inverse of this quaternion.',
                                           'inArgs': [],
                                           'outArgs': [],
                                           'returnInfo': {'doc': 'Quaternion that is the inverse of this quaternion',
                                                          'qualifiers': [],
                                                          'type': 'MQuaternion'},
                                           'returnType': 'MQuaternion',
                                           'static': False,
                                           'typeQualifiers': {},
                                           'types': {}}],
                              'invertIt': [{'argInfo': {},
                                            'args': [],
                                            'defaults': {},
                                            'deprecated': False,
                                            'doc': 'Performs an in place inversion of this quaternion.',
                                            'inArgs': [],
                                            'outArgs': [],
                                            'returnInfo': {'doc': 'A reference to the quaternion that has been inverted',
                                                           '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': 'This 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',
                                                                             '&']},
                                                'types': {'other': 'MQuaternion',
                                                          'tolerance': 'double'}}],
                              'log': [{'argInfo': {},
                                       'args': [],
                                       'defaults': {},
                                       'deprecated': False,
                                       'doc': 'Returns the natural log of a quaternion. The precondition for using this method is that the quaternion must be normalized.',
                                       'inArgs': [],
                                       'outArgs': [],
                                       'returnInfo': {'doc': 'Quaternion that is the log of this quaternion',
                                                      'qualifiers': [],
                                                      'type': 'MQuaternion'},
                                       'returnType': 'MQuaternion',
                                       'static': False,
                                       'typeQualifiers': {},
                                       'types': {}}],
                              'negateIt': [{'argInfo': {},
                                            'args': [],
                                            'defaults': {},
                                            'deprecated': False,
                                            'doc': 'Performs 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': 'A reference to the quaternion that has been negated',
                                                           'qualifiers': ['&'],
                                                           'type': 'MQuaternion'},
                                            'returnType': 'MQuaternion',
                                            'static': False,
                                            'typeQualifiers': {},
                                            'types': {}}],
                              'normal': [{'argInfo': {},
                                          'args': [],
                                          'defaults': {},
                                          'deprecated': False,
                                          'doc': 'Returns the normal of this quaternion. The result is a quaternion of unit length.',
                                          'inArgs': [],
                                          'outArgs': [],
                                          'returnInfo': {'doc': 'Quaternion that is the normal of this quaternion',
                                                         'qualifiers': [],
                                                         'type': 'MQuaternion'},
                                          'returnType': 'MQuaternion',
                                          'static': False,
                                          'typeQualifiers': {},
                                          'types': {}}],
                              'normalizeIt': [{'argInfo': {},
                                               'args': [],
                                               'defaults': {},
                                               'deprecated': False,
                                               'doc': 'Performs an in place normalization of this quaternion. The result is a quaternion of unit length.',
                                               'inArgs': [],
                                               'outArgs': [],
                                               'returnInfo': {'doc': 'A reference to the quaternion that has been normalized',
                                                              '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': 'Performs 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': {},
                                           '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': 'Sets 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',
                                                                            '&']},
                                                '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': 'Sets 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': {},
                                              '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': 'Sets 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': {},
                                              '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': 'Sets 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': {},
                                              'types': {'theta': 'double'}}]},
                  'pymelEnums': {}},
  'MRampAttribute': {'enums': {'MInterpolation': {'valueDocs': {},
                                                  'values': "Enum('MInterpolation', {'kNone': 0, 'kLinear': 1, 'kSmooth': 2, 'kSpline': 3})"}},
                     'methods': {},
                     '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': {}, 'pymelEnums': {}},
  'MRenderData': {'enums': {}, 'methods': {}, 'pymelEnums': {}},
  'MRenderLine': {'enums': {}, 'methods': {}, 'pymelEnums': {}},
  'MRenderLineArray': {'enums': {}, 'methods': {}, 'pymelEnums': {}},
  'MRenderPassDef': {'enums': {}, 'methods': {}, 'pymelEnums': {}},
  'MRenderPassRegistry': {'enums': {}, 'methods': {}, 'pymelEnums': {}},
  'MRenderProfile': {'enums': {'MStandardRenderer': {'valueDocs': {},
                                                     'values': "Enum('MStandardRenderer', {'kMayaSoftware': 0, 'kMayaOpenGL': 1, 'kMayaD3D': 2})"}},
                     'methods': {},
                     'pymelEnums': {'MStandardRenderer': "Enum('MStandardRenderer', [('software', 0), ('kMayaSoftware', 0), ('openGL', 1), ('kMayaOpenGL', 1), ('D3D', 2), ('kMayaD3D', 2)], multiKeys=True)"}},
  'MRenderSetup': {'enums': {}, 'methods': {}, 'pymelEnums': {}},
  'MRenderShadowData': {'enums': {'LightType': {'valueDocs': {},
                                                'values': "Enum('LightType', {'kInvalid': 0, 'kPoint': 1, 'kDirectional': 2, 'kSpot': 3})"}},
                        'methods': {},
                        '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': {}, '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': {},
                  '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': {}, 'pymelEnums': {}},
  'MRenderingInfo': {'enums': {}, 'methods': {}, 'pymelEnums': {}},
  'MRichSelection': {'enums': {}, 'methods': {}, '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 (MFileIO::isReadingFile) is true.',
                                                        '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 (MFileIO::isReadingFile) is true.',
                                                        '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 (MFileIO::isReadingFile) is true.',
                                                        '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 (MFileIO::isReadingFile) is true.',
                                                        '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': {},
                    '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': {}, 'methods': {}, 'pymelEnums': {}},
  'MSelectInfo': {'enums': {}, 'methods': {}, 'pymelEnums': {}},
  '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: If true, the given item is unconditionally added to the end of the list without affecting the pre-existing item. 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': 'Add 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: If true, the given item is unconditionally added to the end of the list without affecting the pre-existing item. 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': 'Add 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': 'Add 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: If true, the given item is unconditionally added to the end of the list without affecting the pre-existing item. 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': 'Add 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': 'Add nodes matching the UUID to the selection list.',
                                          'inArgs': ['uuid',
                                                     'mergeWithExisting'],
                                          'outArgs': [],
                                          'returnInfo': {'doc': '',
                                                         'qualifiers': [],
                                                         'type': None},
                                          'returnType': None,
                                          'static': False,
                                          'typeQualifiers': {'uuid': ['const',
                                                                      '&']},
                                          'types': {'mergeWithExisting': 'bool',
                                                    'uuid': 'MUuid'}}],
                                 'className': [{'argInfo': {},
                                                'args': [],
                                                'defaults': {},
                                                'deprecated': False,
                                                'doc': 'Returns the name of this class.',
                                                'inArgs': [],
                                                'outArgs': [],
                                                'returnInfo': {'doc': 'The name of this class.',
                                                               'qualifiers': ['*'],
                                                               'type': 'char'},
                                                'returnType': 'char',
                                                'static': True,
                                                'typeQualifiers': {},
                                                'types': {}}],
                                 'clear': [{'argInfo': {},
                                            'args': [],
                                            'defaults': {},
                                            'deprecated': False,
                                            'doc': 'This 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': 'Get 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': 'Get 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': 'Get 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'}},
                                             {'argInfo': {'convertComponents': {'doc': 'if true returns the plug of the component in the selection',
                                                                                'type': 'bool'},
                                                          'index': {'doc': 'the items position in the list',
                                                                    'type': 'uint'},
                                                          'plug': {'doc': 'storage for the result',
                                                                   'type': 'MPlug'}},
                                              'args': [('index', 'uint', 'in'),
                                                       ('convertComponents',
                                                        'bool',
                                                        'in'),
                                                       ('plug',
                                                        'MPlug',
                                                        'out')],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': 'Get the plug at the specified index of the selection list.',
                                              'inArgs': ['index',
                                                         'convertComponents'],
                                              'outArgs': ['plug'],
                                              'returnInfo': {'doc': '',
                                                             'qualifiers': [],
                                                             'type': None},
                                              'returnType': None,
                                              'static': False,
                                              'typeQualifiers': {'index': ['unsigned'],
                                                                 'plug': ['&']},
                                              'types': {'convertComponents': 'bool',
                                                        'index': 'uint',
                                                        'plug': 'MPlug'}}],
                                 'getSelectionStrings': [{'argInfo': {'array': {'doc': 'storage for the returned strings',
                                                                                'type': 'MStringArray'}},
                                                          'args': [('array',
                                                                    'MStringArray',
                                                                    'out')],
                                                          'defaults': {},
                                                          'deprecated': False,
                                                          'doc': 'Gets 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': "Gets 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': 'Determines 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': {'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': 'Determines 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': {'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': 'Determines 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': {'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': 'This 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': {'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': 'Modify 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': {'other': ['const',
                                                                             '&']},
                                                'types': {'expandToLeaves': 'bool',
                                                          'other': 'MSelectionList'}}],
                                 'isEmpty': [{'argInfo': {},
                                              'args': [],
                                              'defaults': {},
                                              'deprecated': False,
                                              'doc': 'Specifies 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': {},
                                              'types': {}}],
                                 'length': [{'argInfo': {},
                                             'args': [],
                                             'defaults': {},
                                             'deprecated': False,
                                             'doc': 'This method returns the number of selection items in the list.',
                                             'inArgs': [],
                                             'outArgs': [],
                                             'returnInfo': {'doc': 'Number of items in the list',
                                                            'qualifiers': [],
                                                            'type': 'uint'},
                                             'returnType': 'uint',
                                             'static': False,
                                             'typeQualifiers': {},
                                             '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': 'Merge 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': 'Merge 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': 'Removes 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': 'Remove 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': 'Remove 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': 'Remove 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': 'Removes 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': {},
                                                 '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': {},
                     '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': {}, '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': {}, 'pymelEnums': {}},
  'MSwatchRenderBase': {'enums': {}, 'methods': {}, 'pymelEnums': {}},
  'MSwatchRenderRegister': {'enums': {}, 'methods': {}, 'pymelEnums': {}},
  'MSyntax': {'enums': {'MArgType': {'valueDocs': {},
                                     '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': {},
                                          'values': "Enum('MObjectFormat', {'kInvalidObjectFormat': 0, 'kNone': 1, 'kStringObjects': 2, 'kSelectionList': 3, 'kLastObjectFormat': 4})"}},
              'methods': {},
              '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)"}},
  'MTesselationParams': {'enums': {'IsoparmType': {'valueDocs': {},
                                                   'values': "Enum('IsoparmType', {'kSurface3DDistance': 0, 'kSurface3DEquiSpaced': 1, 'kSurfaceEquiSpaced': 2, 'kSpanEquiSpaced': 3})"},
                                   'PolyType': {'valueDocs': {},
                                                'values': "Enum('PolyType', {'kTriangles': 0, 'kQuads': 1})"},
                                   'SubdivisionType': {'valueDocs': {},
                                                       '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': {},
                                                  'values': "Enum('TessFormat', {'kTriangleCountFormat': 0, 'kStandardFitFormat': 1, 'kGeneralFormat': 2})"}},
                         'methods': {},
                         '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', [('kDrawFunctionFirst', 1), ('kDrawWireframe', 1), ('kDrawEverything', 2), ('kDrawVertexForSelect', 3), ('kDrawEdgeForSelect', 4), ('kDrawFacetForSelect', 5), ('kDrawUVForSelect', 6), ('kDrawFunctionLast', 6)], multiKeys=True)"}},
                             'methods': {},
                             'pymelEnums': {'DrawingFunction': "Enum('DrawingFunction', [('functionFirst', 1), ('kDrawFunctionFirst', 1), ('kDrawWireframe', 1), ('wireframe', 1), ('everything', 2), ('kDrawEverything', 2), ('vertexForSelect', 3), ('kDrawVertexForSelect', 3), ('edgeForSelect', 4), ('kDrawEdgeForSelect', 4), ('facetForSelect', 5), ('kDrawFacetForSelect', 5), ('UVForSelect', 6), ('functionLast', 6), ('kDrawFunctionLast', 6), ('kDrawUVForSelect', 6)], multiKeys=True)"}},
  'MTime': {'enums': {'Unit': {'valueDocs': {'NTSCField': 'DeprecatedUse k60FPS instead.',
                                             'NTSCFrame': 'DeprecatedUse k30FPS instead.',
                                             'PALField': 'DeprecatedUse k50FPS instead.',
                                             'PALFrame': 'DeprecatedUse k25FPS instead.',
                                             'film': 'DeprecatedUse k24FPS instead.',
                                             'games': 'DeprecatedUse k15FPS instead.',
                                             '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',
                                             'k90FPS': '90 frames per second',
                                             'kFilm': 'DeprecatedUse k24FPS instead.',
                                             'kGames': 'DeprecatedUse k15FPS instead.',
                                             'kHours': '3600 seconds',
                                             'kInvalid': 'Invalid value.',
                                             'kLast': 'Last value, used for counting.',
                                             'kMilliseconds': '1/1000 of a second',
                                             'kMinutes': '60 seconds',
                                             'kNTSCField': 'DeprecatedUse k60FPS instead.',
                                             'kNTSCFrame': 'DeprecatedUse k30FPS instead.',
                                             'kPALField': 'DeprecatedUse k50FPS instead.',
                                             'kPALFrame': 'DeprecatedUse k25FPS instead.',
                                             'kSeconds': '1 second',
                                             'kShowScan': 'DeprecatedUse k48FPS instead.',
                                             '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': 'DeprecatedUse k48FPS instead.',
                                             'userDef': 'user defined units (not implemented yet)'},
                               'values': "Enum('Unit', [('kInvalid', 0), ('kHours', 1), ('kMinutes', 2), ('kSeconds', 3), ('kMilliseconds', 4), ('kGames', 5), ('k15FPS', 5), ('kFilm', 6), ('k24FPS', 6), ('kPALFrame', 7), ('k25FPS', 7), ('kNTSCFrame', 8), ('k30FPS', 8), ('kShowScan', 9), ('k48FPS', 9), ('kPALField', 10), ('k50FPS', 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), ('k90FPS', 50), ('kUserDef', 51), ('kLast', 52)], multiKeys=True)"}},
            'invertibles': [('setUnit', 'unit'), ('setValue', 'value')],
            'methods': {'__add__': [{'argInfo': {'rhs': {'doc': 'Right operand.',
                                                         'type': 'MTime'}},
                                     'args': [('rhs', 'MTime', 'in')],
                                     'defaults': {},
                                     'deprecated': False,
                                     'doc': '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': 'Addition with a double.',
                                     'inArgs': ['rhs'],
                                     'outArgs': [],
                                     'returnInfo': {'doc': '',
                                                    'qualifiers': [],
                                                    'type': 'MTime'},
                                     'returnType': 'MTime',
                                     'static': False,
                                     'typeQualifiers': {},
                                     'types': {'rhs': 'double'}}],
                        '__eq__': [{'argInfo': {'rhs': {'doc': 'Right operand.',
                                                        'type': 'MTime'}},
                                    'args': [('rhs', 'MTime', 'in')],
                                    'defaults': {},
                                    'deprecated': False,
                                    'doc': 'Equality 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': 'In-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': 'In-place addition with a double.',
                                      'inArgs': ['rhs'],
                                      'outArgs': [],
                                      'returnInfo': {'doc': '',
                                                     'qualifiers': ['&'],
                                                     'type': 'MTime'},
                                      'returnType': 'MTime',
                                      'static': False,
                                      'typeQualifiers': {},
                                      'types': {'rhs': 'double'}}],
                        '__imul__': [{'argInfo': {'rhs': {'doc': 'the scalar to multiply by.',
                                                          'type': 'double'}},
                                      'args': [('rhs', 'double', 'in')],
                                      'defaults': {},
                                      'deprecated': False,
                                      'doc': 'In 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': {},
                                      'types': {'rhs': 'double'}}],
                        '__isub__': [{'argInfo': {'rhs': {'doc': 'Right operand.',
                                                          'type': 'MTime'}},
                                      'args': [('rhs', 'MTime', 'in')],
                                      'defaults': {},
                                      'deprecated': False,
                                      'doc': 'In-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': 'In-place Subtraction of a double.',
                                      'inArgs': ['rhs'],
                                      'outArgs': [],
                                      'returnInfo': {'doc': '',
                                                     'qualifiers': ['&'],
                                                     'type': 'MTime'},
                                      'returnType': 'MTime',
                                      'static': False,
                                      'typeQualifiers': {},
                                      'types': {'rhs': 'double'}}],
                        '__itruediv__': [{'argInfo': {'rhs': {'doc': 'the scalar to multiply by.',
                                                              'type': 'double'}},
                                          'args': [('rhs', 'double', 'in')],
                                          'defaults': {},
                                          'deprecated': False,
                                          'doc': 'In 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': {},
                                          'types': {'rhs': 'double'}}],
                        '__mul__': [{'argInfo': {'rhs': {'doc': 'the scalar to multiply by.',
                                                         'type': 'double'}},
                                     'args': [('rhs', 'double', 'in')],
                                     'defaults': {},
                                     'deprecated': False,
                                     'doc': 'Multiplication 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': {},
                                     'types': {'rhs': 'double'}}],
                        '__ne__': [{'argInfo': {'rhs': {'doc': 'Right operand.',
                                                        'type': 'MTime'}},
                                    'args': [('rhs', 'MTime', 'in')],
                                    'defaults': {},
                                    'deprecated': False,
                                    'doc': 'InEquality 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': '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': 'Subtraction of a double.',
                                     'inArgs': ['rhs'],
                                     'outArgs': [],
                                     'returnInfo': {'doc': '',
                                                    'qualifiers': [],
                                                    'type': 'MTime'},
                                     'returnType': 'MTime',
                                     'static': False,
                                     'typeQualifiers': {},
                                     'types': {'rhs': 'double'}}],
                        '__truediv__': [{'argInfo': {'rhs': {'doc': 'the scalar to divide by.',
                                                             'type': 'double'}},
                                         'args': [('rhs', 'double', 'in')],
                                         'defaults': {},
                                         'deprecated': False,
                                         'doc': 'Division 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': {},
                                         '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': 'Returns 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': {},
                                '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': 'Returns 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': {},
                                     'types': {'newUnit': ('MTime', 'Unit')}}],
                        'className': [{'argInfo': {},
                                       'args': [],
                                       'defaults': {},
                                       'deprecated': False,
                                       'doc': 'Returns the name of this class.',
                                       'inArgs': [],
                                       'outArgs': [],
                                       'returnInfo': {'doc': 'The name of this class.',
                                                      'qualifiers': ['*'],
                                                      'type': 'char'},
                                       'returnType': 'char',
                                       'static': True,
                                       'typeQualifiers': {},
                                       'types': {}}],
                        'copy': [{'argInfo': {'rhs': {'doc': '',
                                                      'type': 'MTime'}},
                                  'args': [('rhs', 'MTime', 'in')],
                                  'defaults': {},
                                  'deprecated': False,
                                  'doc': '',
                                  'inArgs': ['rhs'],
                                  'outArgs': [],
                                  'returnInfo': {'doc': '',
                                                 'qualifiers': ['&'],
                                                 'type': 'MTime'},
                                  'returnType': 'MTime',
                                  'static': False,
                                  'typeQualifiers': {'rhs': ['const', '&']},
                                  'types': {'rhs': 'MTime'}}],
                        'setUIUnit': [{'argInfo': {'newUnit': {'doc': 'an element of the MTime::Unit enum',
                                                               'type': ('MTime',
                                                                        'Unit')}},
                                       'args': [('newUnit',
                                                 ('MTime', 'Unit'),
                                                 'in')],
                                       'defaults': {},
                                       'deprecated': False,
                                       'doc': "Set 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': {},
                                       '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': 'Set 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': {},
                                     'types': {'newUnit': ('MTime', 'Unit')}}],
                        'setValue': [{'argInfo': {'newValue': {'doc': 'The new time value.',
                                                               'type': 'double'}},
                                      'args': [('newValue', 'double', 'in')],
                                      'defaults': {},
                                      'deprecated': False,
                                      'doc': 'Set 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': {},
                                      'types': {'newValue': 'double'}}],
                        'ticksPerSecond': [{'argInfo': {},
                                            'args': [],
                                            'defaults': {},
                                            'deprecated': False,
                                            'doc': 'Returns the number of ticks per second, the smallest unit of time available.',
                                            'inArgs': [],
                                            'outArgs': [],
                                            'returnInfo': {'doc': 'The number of ticks per second.',
                                                           'qualifiers': [],
                                                           'type': ('MTime',
                                                                    'MTick')},
                                            'returnType': ('MTime', 'MTick'),
                                            'static': True,
                                            'typeQualifiers': {},
                                            'types': {}}],
                        'uiUnit': [{'argInfo': {},
                                    'args': [],
                                    'defaults': {},
                                    'deprecated': False,
                                    'doc': "Returns 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': 'Returns the current units in effect for this instance.',
                                  'inArgs': [],
                                  'inverse': ('setUnit', False),
                                  'outArgs': [],
                                  'returnInfo': {'doc': 'An element of the MTime::Unit enum',
                                                 'qualifiers': [],
                                                 'type': ('MTime', 'Unit')},
                                  'returnType': ('MTime', 'Unit'),
                                  'static': False,
                                  'typeQualifiers': {},
                                  'types': {}}],
                        'value': [{'argInfo': {},
                                   'args': [],
                                   'defaults': {},
                                   'deprecated': False,
                                   'doc': 'Returns 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), ('games', 5), ('k15FPS', 5), ('kGames', 5), ('film', 6), ('k24FPS', 6), ('kFilm', 6), ('PALFrame', 7), ('k25FPS', 7), ('kPALFrame', 7), ('NTSCFrame', 8), ('k30FPS', 8), ('kNTSCFrame', 8), ('showScan', 9), ('k48FPS', 9), ('kShowScan', 9), ('PALField', 10), ('k50FPS', 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), ('k90FPS', 50), ('userDef', 51), ('kUserDef', 51), ('last', 52), ('kLast', 52)], multiKeys=True)"},
            'pymelMethods': {'unit': 'getUnit', 'value': 'getValue'}},
  'MTimeArray': {'enums': {}, 'methods': {}, 'pymelEnums': {}},
  'MTimeRange': {'enums': {}, 'methods': {}, 'pymelEnums': {}},
  'MTimer': {'enums': {}, 'methods': {}, 'pymelEnums': {}},
  'MTimerMessage': {'enums': {}, 'methods': {}, 'pymelEnums': {}},
  'MToolsInfo': {'enums': {}, 'methods': {}, 'pymelEnums': {}},
  'MTransformationMatrix': {'enums': {'RotationOrder': {'valueDocs': {},
                                                        'values': "Enum('RotationOrder', {'kInvalid': 0, 'kXYZ': 1, 'kYZX': 2, 'kZXY': 3, 'kXZY': 4, 'kYXZ': 5, 'kZYX': 6, 'kLast': 7})"}},
                            'invertibles': [('setRotatePivot', 'rotatePivot'),
                                            ('setRotatePivotTranslation',
                                             'rotatePivotTranslation'),
                                            ('setRotation', 'rotation'),
                                            ('setRotationOrientation',
                                             'rotationOrientation'),
                                            ('setRotationQuaternion',
                                             'getRotationQuaternion'),
                                            ('setScale', 'getScale'),
                                            ('setScalePivot', 'scalePivot'),
                                            ('setScalePivotTranslation',
                                             'scalePivotTranslation'),
                                            ('setShear', 'getShear'),
                                            ('setTranslation', 'translation')],
                            'methods': {'__eq__': [{'argInfo': {'other': {'doc': 'transform matrix to test against',
                                                                          'type': 'MTransformationMatrix'}},
                                                    'args': [('other',
                                                              'MTransformationMatrix',
                                                              'in')],
                                                    'defaults': {},
                                                    'deprecated': False,
                                                    'doc': 'Equality 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': 'Inequality 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': 'Add 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': {'rot': ['const']},
                                                         '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': 'Add 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': {},
                                                                   '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': 'Add 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']},
                                                      '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': 'Add 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']},
                                                      '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': 'Add 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': {'vector': ['const',
                                                                                          '&']},
                                                            'types': {'space': ('MSpace',
                                                                                'Space'),
                                                                      'vector': 'MVector'}}],
                                        'asMatrix': [{'argInfo': {},
                                                      'args': [],
                                                      'defaults': {},
                                                      'deprecated': False,
                                                      'doc': 'Returns 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': 'Returns 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': {},
                                                      'types': {'percent': 'double'}}],
                                        'asMatrixInverse': [{'argInfo': {},
                                                             'args': [],
                                                             'defaults': {},
                                                             'deprecated': False,
                                                             'doc': 'Returns the inverse of the four by four matrix that describes this transformation.',
                                                             'inArgs': [],
                                                             'outArgs': [],
                                                             'returnInfo': {'doc': 'The matrix',
                                                                            'qualifiers': [],
                                                                            'type': 'MMatrix'},
                                                             'returnType': 'MMatrix',
                                                             'static': False,
                                                             'typeQualifiers': {},
                                                             'types': {}}],
                                        'asRotateMatrix': [{'argInfo': {},
                                                            'args': [],
                                                            'defaults': {},
                                                            'deprecated': False,
                                                            'doc': 'Returns 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': 'Returns 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': 'The scale space matrix',
                                                                          'qualifiers': [],
                                                                          'type': 'MMatrix'},
                                                           'returnType': 'MMatrix',
                                                           'static': False,
                                                           'typeQualifiers': {},
                                                           'types': {}}],
                                        'className': [{'argInfo': {},
                                                       'args': [],
                                                       'defaults': {},
                                                       'deprecated': False,
                                                       'doc': 'Returns the name of this class.',
                                                       'inArgs': [],
                                                       'outArgs': [],
                                                       'returnInfo': {'doc': 'Name of this class.',
                                                                      'qualifiers': ['*'],
                                                                      'type': 'char'},
                                                       'returnType': 'char',
                                                       'static': True,
                                                       'typeQualifiers': {},
                                                       'types': {}}],
                                        'eulerRotation': [{'argInfo': {},
                                                           'args': [],
                                                           'defaults': {},
                                                           'deprecated': False,
                                                           'doc': 'Returns the rotation component of the transformation matrix as an euler rotation.',
                                                           'inArgs': [],
                                                           'outArgs': [],
                                                           'returnInfo': {'doc': 'Euler rotation that is the rotation component of the transformation matrix',
                                                                          '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': 'Get 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': ['&']},
                                                         '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': 'This method is obsolete. [as of Maya 2019]',
                                                         'inArgs': ['space'],
                                                         'outArgs': ['rot',
                                                                     'order'],
                                                         'returnInfo': {'doc': '',
                                                                        'qualifiers': [],
                                                                        'type': None},
                                                         'returnType': None,
                                                         'static': False,
                                                         'typeQualifiers': {'order': ['&']},
                                                         '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': 'Get 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': 'This method is obsolete. [as of Maya 2019]',
                                                                   'inArgs': ['space'],
                                                                   'inverse': ('setRotationQuaternion',
                                                                               False),
                                                                   'outArgs': ['x',
                                                                               'y',
                                                                               'z',
                                                                               'w'],
                                                                   'returnInfo': {'doc': '',
                                                                                  'qualifiers': [],
                                                                                  'type': None},
                                                                   'returnType': None,
                                                                   'static': False,
                                                                   'typeQualifiers': {'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': 'Get the scale component of the transformation matrix.',
                                                      'inArgs': ['space'],
                                                      'inverse': ('setScale',
                                                                  False),
                                                      'outArgs': ['scale'],
                                                      'returnInfo': {'doc': '',
                                                                     'qualifiers': [],
                                                                     'type': None},
                                                      'returnType': None,
                                                      'static': False,
                                                      'typeQualifiers': {},
                                                      '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': 'Get the shear component of the transformation matrix.',
                                                      'inArgs': ['space'],
                                                      'inverse': ('setShear',
                                                                  False),
                                                      'outArgs': ['shear'],
                                                      'returnInfo': {'doc': '',
                                                                     'qualifiers': [],
                                                                     'type': None},
                                                      'returnType': None,
                                                      'static': False,
                                                      'typeQualifiers': {},
                                                      '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': 'Returns 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': {},
                                                            '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': 'Returns 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',
                                                                                       '&']},
                                                          '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': 'Reorders 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': 'Adds 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/MSpace::kObject. 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': {'q': ['const',
                                                                               '&']},
                                                      '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': 'Adds 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/MSpace::kObject. 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': {'e': ['const',
                                                                               '&']},
                                                      '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': 'Returns 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': {},
                                                         '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': 'Returns 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': {},
                                                                    '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': 'Sets 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': 'Sets 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': 'Returns 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': 'Quaternion that is the rotation component of the transformation matrix',
                                                                     'qualifiers': [],
                                                                     'type': 'MQuaternion'},
                                                      'returnType': 'MQuaternion',
                                                      'static': False,
                                                      'typeQualifiers': {},
                                                      'types': {}}],
                                        'rotationOrder': [{'argInfo': {},
                                                           'args': [],
                                                           'defaults': {},
                                                           'deprecated': False,
                                                           'doc': 'Returns 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': {},
                                                           'types': {}}],
                                        'rotationOrientation': [{'argInfo': {},
                                                                 'args': [],
                                                                 'defaults': {},
                                                                 'deprecated': False,
                                                                 'doc': 'Returns 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': 'Rotation orientation',
                                                                                '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': 'Returns 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': {},
                                                        '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': 'Returns 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': {},
                                                                   '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': 'Set 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': {'point': ['const',
                                                                                         '&']},
                                                            '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': 'Set 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': {'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': 'Set 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': {'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': 'This method is obsolete. [as of Maya 2019]',
                                                         'inArgs': ['rot',
                                                                    'order',
                                                                    'space'],
                                                         'inverse': ('rotation',
                                                                     True),
                                                         'outArgs': [],
                                                         'returnInfo': {'doc': '',
                                                                        'qualifiers': [],
                                                                        'type': None},
                                                         'returnType': None,
                                                         'static': False,
                                                         'typeQualifiers': {'rot': ['const']},
                                                         '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': 'Sets 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': 'Set 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': {},
                                                                   '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': 'This method is obsolete. [as of Maya 2019]',
                                                                   'inArgs': ['x',
                                                                              'y',
                                                                              'z',
                                                                              'w',
                                                                              'space'],
                                                                   'inverse': ('getRotationQuaternion',
                                                                               True),
                                                                   'outArgs': [],
                                                                   'returnInfo': {'doc': '',
                                                                                  'qualifiers': [],
                                                                                  'type': None},
                                                                   'returnType': None,
                                                                   'static': False,
                                                                   'typeQualifiers': {},
                                                                   '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': 'Set 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']},
                                                      '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': 'Set 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': {'point': ['const',
                                                                                        '&']},
                                                           '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': 'Set 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': {'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': 'Set 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']},
                                                      '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': 'Sets 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',
                                                                                           '&']},
                                                               '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': 'Set 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': {'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': 'This method is obsolete. [as of Maya 2019]',
                                                         'inArgs': ['space'],
                                                         'inverse': ('setTranslation',
                                                                     False),
                                                         'outArgs': [],
                                                         'returnInfo': {'doc': 'Translation vector in centimeters',
                                                                        'qualifiers': [],
                                                                        'type': 'MVector'},
                                                         'returnType': 'MVector',
                                                         'static': False,
                                                         'typeQualifiers': {},
                                                         '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': {}, 'pymelEnums': {}},
  'MTypeId': {'enums': {}, 'methods': {}, 'pymelEnums': {}},
  'MURI': {'enums': {}, 'methods': {}, 'pymelEnums': {}},
  'MUiMessage': {'enums': {}, 'methods': {}, 'pymelEnums': {}},
  'MUint64Array': {'enums': {}, 'methods': {}, 'pymelEnums': {}},
  'MUintArray': {'enums': {}, 'methods': {}, 'pymelEnums': {}},
  'MUniformParameter': {'enums': {'DataSemantic': {'valueDocs': {},
                                                   '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': {},
                                               '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})"}},
                        'methods': {},
                        '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)"}},
  'MUniformParameterList': {'enums': {}, 'methods': {}, 'pymelEnums': {}},
  'MUserData': {'enums': {}, 'methods': {}, 'pymelEnums': {}},
  'MUserEventMessage': {'enums': {}, 'methods': {}, 'pymelEnums': {}},
  'MUuid': {'enums': {}, 'methods': {}, 'pymelEnums': {}},
  'MVaryingParameter': {'enums': {'MVaryingParameterSemantic': {'valueDocs': {},
                                                                'values': "Enum('MVaryingParameterSemantic', {'kNoSemantic': 0, 'kPosition': 1, 'kNormal': 2, 'kTexCoord': 3, 'kColor': 4, 'kWeight': 5, 'kTangent': 7, 'kBinormal': 8})"},
                                  'MVaryingParameterType': {'valueDocs': {},
                                                            'values': "Enum('MVaryingParameterType', {'kInvalidParameter': -1, 'kStructure': 0, 'kFloat': 1, 'kDouble': 2, 'kChar': 3, 'kUnsignedChar': 4, 'kInt16': 5, 'kUnsignedInt16': 6, 'kInt32': 7, 'kUnsignedInt32': 8})"}},
                        'methods': {},
                        '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': {}, 'methods': {}, 'pymelEnums': {}},
  'MVector': {'enums': {'Axis': {'valueDocs': {},
                                 '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': 'The vector addition operator.',
                                       'inArgs': ['other'],
                                       'outArgs': [],
                                       'returnInfo': {'doc': '',
                                                      'qualifiers': [],
                                                      'type': 'MVector'},
                                       'returnType': 'MVector',
                                       'static': False,
                                       'typeQualifiers': {'other': ['const',
                                                                    '&']},
                                       'types': {'other': 'MVector'}}],
                          '__eq__': [{'argInfo': {'other': {'doc': 'The vector to compare to.',
                                                            'type': 'MVector'}},
                                      'args': [('other', 'MVector', 'in')],
                                      'defaults': {},
                                      'deprecated': False,
                                      'doc': 'The 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': 'The 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'}}],
                          '__iadd__': [{'argInfo': {'other': {'doc': 'Vector to add.',
                                                              'type': 'MVector'}},
                                        'args': [('other', 'MVector', 'in')],
                                        'defaults': {},
                                        'deprecated': False,
                                        'doc': 'The in place vector addition operator.',
                                        'inArgs': ['other'],
                                        'outArgs': [],
                                        'returnInfo': {'doc': '',
                                                       'qualifiers': ['&'],
                                                       'type': 'MVector'},
                                        'returnType': 'MVector',
                                        'static': False,
                                        'typeQualifiers': {'other': ['const',
                                                                     '&']},
                                        'types': {'other': 'MVector'}}],
                          '__imul__': [{'argInfo': {'scalar': {'doc': 'Scale factor.',
                                                               'type': 'int'}},
                                        'args': [('scalar', 'int', 'in')],
                                        'defaults': {},
                                        'deprecated': False,
                                        'doc': 'The in place multiplication operator.',
                                        'inArgs': ['scalar'],
                                        'outArgs': [],
                                        'returnInfo': {'doc': '',
                                                       'qualifiers': ['&'],
                                                       'type': 'MVector'},
                                        'returnType': 'MVector',
                                        'static': False,
                                        'typeQualifiers': {},
                                        'types': {'scalar': 'int'}},
                                       {'argInfo': {'scalar': {'doc': 'Scale factor.',
                                                               'type': 'short'}},
                                        'args': [('scalar', 'short', 'in')],
                                        'defaults': {},
                                        'deprecated': False,
                                        'doc': 'The in place multiplication operator.',
                                        'inArgs': ['scalar'],
                                        'outArgs': [],
                                        'returnInfo': {'doc': '',
                                                       'qualifiers': ['&'],
                                                       'type': 'MVector'},
                                        'returnType': 'MVector',
                                        'static': False,
                                        'typeQualifiers': {},
                                        'types': {'scalar': 'short'}},
                                       {'argInfo': {'scalar': {'doc': 'Scale factor.',
                                                               'type': 'uint'}},
                                        'args': [('scalar', 'uint', 'in')],
                                        'defaults': {},
                                        'deprecated': False,
                                        'doc': 'The 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': 'The 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': 'The in place multiplication operator.',
                                        'inArgs': ['scalar'],
                                        'outArgs': [],
                                        'returnInfo': {'doc': '',
                                                       'qualifiers': ['&'],
                                                       'type': 'MVector'},
                                        'returnType': 'MVector',
                                        'static': False,
                                        'typeQualifiers': {},
                                        'types': {'scalar': 'float'}},
                                       {'argInfo': {'scalar': {'doc': 'Scale factor.',
                                                               'type': 'double'}},
                                        'args': [('scalar', 'double', 'in')],
                                        'defaults': {},
                                        'deprecated': False,
                                        'doc': 'The in place multiplication operator.',
                                        'inArgs': ['scalar'],
                                        'outArgs': [],
                                        'returnInfo': {'doc': '',
                                                       'qualifiers': ['&'],
                                                       'type': 'MVector'},
                                        'returnType': 'MVector',
                                        'static': False,
                                        'typeQualifiers': {},
                                        'types': {'scalar': 'double'}},
                                       {'argInfo': {'right': {'doc': '',
                                                              'type': 'MMatrix'}},
                                        'args': [('right', 'MMatrix', 'in')],
                                        'defaults': {},
                                        'deprecated': False,
                                        'doc': 'The in place matrix multiplication operator.',
                                        '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': 'The in place vector subtraction operator.',
                                        'inArgs': ['other'],
                                        'outArgs': [],
                                        'returnInfo': {'doc': '',
                                                       'qualifiers': ['&'],
                                                       'type': 'MVector'},
                                        'returnType': 'MVector',
                                        'static': False,
                                        'typeQualifiers': {'other': ['const',
                                                                     '&']},
                                        'types': {'other': 'MVector'}}],
                          '__itruediv__': [{'argInfo': {'scalar': {'doc': 'Division factor.',
                                                                   'type': 'double'}},
                                            'args': [('scalar',
                                                      'double',
                                                      'in')],
                                            'defaults': {},
                                            'deprecated': False,
                                            'doc': 'The in place division operator.',
                                            'inArgs': ['scalar'],
                                            'outArgs': [],
                                            'returnInfo': {'doc': '',
                                                           'qualifiers': ['&'],
                                                           'type': 'MVector'},
                                            'returnType': 'MVector',
                                            'static': False,
                                            'typeQualifiers': {},
                                            'types': {'scalar': 'double'}}],
                          '__mul__': [{'argInfo': {'right': {'doc': 'Vector to take the dot product with.',
                                                             'type': 'MVector'}},
                                       'args': [('right', 'MVector', 'in')],
                                       'defaults': {},
                                       'deprecated': False,
                                       'doc': 'The 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': 'The multiplication operator.',
                                       'inArgs': ['scalar'],
                                       'outArgs': [],
                                       'returnInfo': {'doc': '',
                                                      'qualifiers': [],
                                                      'type': 'MVector'},
                                       'returnType': 'MVector',
                                       'static': False,
                                       'typeQualifiers': {},
                                       'types': {'scalar': 'int'}},
                                      {'argInfo': {'scalar': {'doc': 'Scale factor.',
                                                              'type': 'short'}},
                                       'args': [('scalar', 'short', 'in')],
                                       'defaults': {},
                                       'deprecated': False,
                                       'doc': 'The multiplication operator.',
                                       'inArgs': ['scalar'],
                                       'outArgs': [],
                                       'returnInfo': {'doc': '',
                                                      'qualifiers': [],
                                                      'type': 'MVector'},
                                       'returnType': 'MVector',
                                       'static': False,
                                       'typeQualifiers': {},
                                       'types': {'scalar': 'short'}},
                                      {'argInfo': {'scalar': {'doc': 'Scale factor.',
                                                              'type': 'uint'}},
                                       'args': [('scalar', 'uint', 'in')],
                                       'defaults': {},
                                       'deprecated': False,
                                       'doc': 'The 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': 'The 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': 'The multiplication operator.',
                                       'inArgs': ['scalar'],
                                       'outArgs': [],
                                       'returnInfo': {'doc': '',
                                                      'qualifiers': [],
                                                      'type': 'MVector'},
                                       'returnType': 'MVector',
                                       'static': False,
                                       'typeQualifiers': {},
                                       'types': {'scalar': 'float'}},
                                      {'argInfo': {'scalar': {'doc': 'Scale factor.',
                                                              'type': 'double'}},
                                       'args': [('scalar', 'double', 'in')],
                                       'defaults': {},
                                       'deprecated': False,
                                       'doc': 'The multiplication operator.',
                                       'inArgs': ['scalar'],
                                       'outArgs': [],
                                       'returnInfo': {'doc': '',
                                                      'qualifiers': [],
                                                      'type': 'MVector'},
                                       'returnType': 'MVector',
                                       'static': False,
                                       'typeQualifiers': {},
                                       'types': {'scalar': 'double'}},
                                      {'argInfo': {'right': {'doc': '',
                                                             'type': 'MMatrix'}},
                                       'args': [('right', 'MMatrix', 'in')],
                                       'defaults': {},
                                       'deprecated': False,
                                       'doc': 'The matrix multiplication operator.',
                                       'inArgs': ['right'],
                                       'outArgs': [],
                                       'returnInfo': {'doc': '',
                                                      'qualifiers': [],
                                                      'type': 'MVector'},
                                       'returnType': 'MVector',
                                       'static': False,
                                       'typeQualifiers': {'right': ['const',
                                                                    '&']},
                                       'types': {'right': 'MMatrix'}}],
                          '__ne__': [{'argInfo': {'other': {'doc': 'The vector to compare to.',
                                                            'type': 'MVector'}},
                                      'args': [('other', 'MVector', 'in')],
                                      'defaults': {},
                                      'deprecated': False,
                                      'doc': 'The 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': 'The unary minus operator. Negates the value of each of the x, y, and z components of the vector.',
                                       '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': 'The vector subtraction operator.',
                                       'inArgs': ['other'],
                                       'outArgs': [],
                                       'returnInfo': {'doc': '',
                                                      'qualifiers': [],
                                                      'type': 'MVector'},
                                       'returnType': 'MVector',
                                       'static': False,
                                       'typeQualifiers': {'other': ['const',
                                                                    '&']},
                                       'types': {'other': 'MVector'}}],
                          '__truediv__': [{'argInfo': {'scalar': {'doc': 'Division factor.',
                                                                  'type': 'double'}},
                                           'args': [('scalar', 'double', 'in')],
                                           'defaults': {},
                                           'deprecated': False,
                                           'doc': 'The division operator.',
                                           'inArgs': ['scalar'],
                                           'outArgs': [],
                                           'returnInfo': {'doc': '',
                                                          'qualifiers': [],
                                                          'type': 'MVector'},
                                           'returnType': 'MVector',
                                           'static': False,
                                           'typeQualifiers': {},
                                           'types': {'scalar': 'double'}}],
                          'angle': [{'argInfo': {'other': {'doc': 'the vector from which to compute the angle.',
                                                           'type': 'MVector'}},
                                     'args': [('other', 'MVector', 'in')],
                                     'defaults': {},
                                     'deprecated': False,
                                     'doc': 'Returns 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': 'Extracts 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': {},
                                   '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': 'Returns 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',
                                                                         '&']},
                                            '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': 'Returns 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',
                                                                       '&']},
                                          'types': {'other': 'MVector',
                                                    'tol': 'double'}}],
                          'length': [{'argInfo': {},
                                      'args': [],
                                      'defaults': {},
                                      'deprecated': False,
                                      'doc': 'Return the length of the vector.',
                                      'inArgs': [],
                                      'outArgs': [],
                                      'returnInfo': {'doc': '',
                                                     'qualifiers': [],
                                                     'type': 'double'},
                                      'returnType': 'double',
                                      'static': False,
                                      'typeQualifiers': {},
                                      'types': {}}],
                          'normal': [{'argInfo': {},
                                      'args': [],
                                      'defaults': {},
                                      'deprecated': False,
                                      'doc': 'Return a normalized copy of this vector.',
                                      'inArgs': [],
                                      'outArgs': [],
                                      'returnInfo': {'doc': '',
                                                     'qualifiers': [],
                                                     'type': 'MVector'},
                                      'returnType': 'MVector',
                                      'static': False,
                                      'typeQualifiers': {},
                                      'types': {}}],
                          'normalize': [{'argInfo': {},
                                         'args': [],
                                         'defaults': {},
                                         'deprecated': False,
                                         'doc': 'Performs 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': 'Returns 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': {},
                                        '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': 'Returns 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': {'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': 'Returns 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']},
                                        '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': 'Returns 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': 'Returns 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': 'Returns 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': 'This 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': {}, 'methods': {}, 'pymelEnums': {}},
  '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})"},
                                  'RenderingExclusion': {'valueDocs': {},
                                                         'values': "Enum('RenderingExclusion', {'kExcludePluginShapes': -2147483648, 'kExcludeAll': -1, 'kExcludeNone': 0, 'kExcludeNurbsCurves': 1, 'kExcludeNurbsSurfaces': 2, 'kExcludeMeshes': 4, 'kExcludePlanes': 8, 'kExcludeLights': 16, 'kExcludeCameras': 32, 'kExcludeJoints': 64, 'kExcludeIkHandles': 128, 'kExcludeDeformers': 256, 'kExcludeDynamics': 512, 'kExcludeParticleInstancers': 1024, 'kExcludeLocators': 2048, 'kExcludeDimensions': 4096, 'kExcludeSelectHandles': 8192, 'kExcludePivots': 16384, 'kExcludeTextures': 32768, 'kExcludeGrid': 65536, 'kExcludeCVs': 131072, 'kExcludeHulls': 262144, 'kExcludeStrokes': 524288, 'kExcludeSubdivSurfaces': 1048576, 'kExcludeFluids': 2097152, 'kExcludeFollicles': 4194304, 'kExcludeHairSystems': 8388608, 'kExcludeImagePlane': 16777216, 'kExcludeNCloths': 33554432, 'kExcludeNRigids': 67108864, 'kExcludeDynamicConstraints': 134217728, 'kExcludeManipulators': 268435456, 'kExcludeNParticles': 536870912, 'kExcludeMotionTrails': 1073741824})"},
                                  '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})"}},
                        'methods': {},
                        'pymelEnums': {'RenderingAPI': "Enum('RenderingAPI', [('openGL', 0), ('kOpenGL', 0), ('direct3D', 1), ('kDirect3D', 1), ('software', 2), ('kSoftware', 2)], multiKeys=True)",
                                       'RenderingExclusion': "Enum('RenderingExclusion', [('pluginShapes', -2147483648), ('kExcludePluginShapes', -2147483648), ('all', -1), ('kExcludeAll', -1), ('none', 0), ('kExcludeNone', 0), ('nurbsCurves', 1), ('kExcludeNurbsCurves', 1), ('nurbsSurfaces', 2), ('kExcludeNurbsSurfaces', 2), ('meshes', 4), ('kExcludeMeshes', 4), ('planes', 8), ('kExcludePlanes', 8), ('lights', 16), ('kExcludeLights', 16), ('cameras', 32), ('kExcludeCameras', 32), ('joints', 64), ('kExcludeJoints', 64), ('ikHandles', 128), ('kExcludeIkHandles', 128), ('deformers', 256), ('kExcludeDeformers', 256), ('dynamics', 512), ('kExcludeDynamics', 512), ('particleInstancers', 1024), ('kExcludeParticleInstancers', 1024), ('locators', 2048), ('kExcludeLocators', 2048), ('dimensions', 4096), ('kExcludeDimensions', 4096), ('selectHandles', 8192), ('kExcludeSelectHandles', 8192), ('pivots', 16384), ('kExcludePivots', 16384), ('textures', 32768), ('kExcludeTextures', 32768), ('grid', 65536), ('kExcludeGrid', 65536), ('CVs', 131072), ('kExcludeCVs', 131072), ('hulls', 262144), ('kExcludeHulls', 262144), ('strokes', 524288), ('kExcludeStrokes', 524288), ('subdivSurfaces', 1048576), ('kExcludeSubdivSurfaces', 1048576), ('fluids', 2097152), ('kExcludeFluids', 2097152), ('follicles', 4194304), ('kExcludeFollicles', 4194304), ('hairSystems', 8388608), ('kExcludeHairSystems', 8388608), ('imagePlane', 16777216), ('kExcludeImagePlane', 16777216), ('NCloths', 33554432), ('kExcludeNCloths', 33554432), ('NRigids', 67108864), ('kExcludeNRigids', 67108864), ('dynamicConstraints', 134217728), ('kExcludeDynamicConstraints', 134217728), ('manipulators', 268435456), ('kExcludeManipulators', 268435456), ('NParticles', 536870912), ('kExcludeNParticles', 536870912), ('motionTrails', 1073741824), ('kExcludeMotionTrails', 1073741824)], multiKeys=True)",
                                       'RenderingOverride': "Enum('RenderingOverride', [('noOverride', 0), ('kNoOverride', 0), ('overrideAllDrawing', 1), ('kOverrideAllDrawing', 1), ('overrideThenStandard', 2), ('kOverrideThenStandard', 2), ('overrideThenUI', 3), ('kOverrideThenUI', 3)], multiKeys=True)"}},
  'MWeight': {'enums': {}, 'methods': {}, 'pymelEnums': {}},
  'MaterialInputData': {'enums': {}, 'methods': {}, 'pymelEnums': {}},
  'MnCloth': {'enums': {}, 'methods': {}, 'pymelEnums': {}},
  'MnObject': {'enums': {}, 'methods': {}, 'pymelEnums': {}},
  'MnParticle': {'enums': {}, 'methods': {}, 'pymelEnums': {}},
  'MnRigid': {'enums': {}, 'methods': {}, 'pymelEnums': {}},
  'MnSolver': {'enums': {}, 'methods': {}, 'pymelEnums': {}}})