from OpenMaya import *

class MVector(object):
    """
    3D vector with double-precision coordinates.
    """
    
    
    
    def __add__(*args, **kwargs):
        """
        x.__add__(y) <==> x+y
        """
    
        pass
    
    
    def __delitem__(*args, **kwargs):
        """
        x.__delitem__(y) <==> del x[y]
        """
    
        pass
    
    
    def __div__(*args, **kwargs):
        """
        x.__div__(y) <==> x/y
        """
    
        pass
    
    
    def __eq__(*args, **kwargs):
        """
        x.__eq__(y) <==> x==y
        """
    
        pass
    
    
    def __ge__(*args, **kwargs):
        """
        x.__ge__(y) <==> x>=y
        """
    
        pass
    
    
    def __getitem__(*args, **kwargs):
        """
        x.__getitem__(y) <==> x[y]
        """
    
        pass
    
    
    def __gt__(*args, **kwargs):
        """
        x.__gt__(y) <==> x>y
        """
    
        pass
    
    
    def __iadd__(*args, **kwargs):
        """
        x.__iadd__(y) <==> x+y
        """
    
        pass
    
    
    def __idiv__(*args, **kwargs):
        """
        x.__idiv__(y) <==> x/y
        """
    
        pass
    
    
    def __imul__(*args, **kwargs):
        """
        x.__imul__(y) <==> x*y
        """
    
        pass
    
    
    def __init__(*args, **kwargs):
        """
        x.__init__(...) initializes x; see x.__class__.__doc__ for signature
        """
    
        pass
    
    
    def __isub__(*args, **kwargs):
        """
        x.__isub__(y) <==> x-y
        """
    
        pass
    
    
    def __le__(*args, **kwargs):
        """
        x.__le__(y) <==> x<=y
        """
    
        pass
    
    
    def __len__(*args, **kwargs):
        """
        x.__len__() <==> len(x)
        """
    
        pass
    
    
    def __lt__(*args, **kwargs):
        """
        x.__lt__(y) <==> x<y
        """
    
        pass
    
    
    def __mul__(*args, **kwargs):
        """
        x.__mul__(y) <==> x*y
        """
    
        pass
    
    
    def __ne__(*args, **kwargs):
        """
        x.__ne__(y) <==> x!=y
        """
    
        pass
    
    
    def __neg__(*args, **kwargs):
        """
        x.__neg__() <==> -x
        """
    
        pass
    
    
    def __radd__(*args, **kwargs):
        """
        x.__radd__(y) <==> y+x
        """
    
        pass
    
    
    def __rdiv__(*args, **kwargs):
        """
        x.__rdiv__(y) <==> y/x
        """
    
        pass
    
    
    def __repr__(*args, **kwargs):
        """
        x.__repr__() <==> repr(x)
        """
    
        pass
    
    
    def __rmul__(*args, **kwargs):
        """
        x.__rmul__(y) <==> y*x
        """
    
        pass
    
    
    def __rsub__(*args, **kwargs):
        """
        x.__rsub__(y) <==> y-x
        """
    
        pass
    
    
    def __rxor__(*args, **kwargs):
        """
        x.__rxor__(y) <==> y^x
        """
    
        pass
    
    
    def __setitem__(*args, **kwargs):
        """
        x.__setitem__(i, y) <==> x[i]=y
        """
    
        pass
    
    
    def __str__(*args, **kwargs):
        """
        x.__str__() <==> str(x)
        """
    
        pass
    
    
    def __sub__(*args, **kwargs):
        """
        x.__sub__(y) <==> x-y
        """
    
        pass
    
    
    def __xor__(*args, **kwargs):
        """
        x.__xor__(y) <==> x^y
        """
    
        pass
    
    
    def angle(*args, **kwargs):
        """
        Returns the angle, in radians, between this vector and another.
        """
    
        pass
    
    
    def isEquivalent(*args, **kwargs):
        """
        Returns True if this vector and another are within a given tolerance of being equal.
        """
    
        pass
    
    
    def isParallel(*args, **kwargs):
        """
        Returns True if this vector and another are within the given tolerance of being parallel.
        """
    
        pass
    
    
    def length(*args, **kwargs):
        """
        Returns the magnitude of this vector.
        """
    
        pass
    
    
    def normal(*args, **kwargs):
        """
        Returns a new vector containing the normalized version of this one.
        """
    
        pass
    
    
    def normalize(*args, **kwargs):
        """
        Normalizes this vector in-place and returns a new reference to it.
        """
    
        pass
    
    
    def rotateBy(*args, **kwargs):
        """
        Returns the vector resulting from rotating this one by the given amount.
        """
    
        pass
    
    
    def rotateTo(*args, **kwargs):
        """
        Returns the quaternion which will rotate this vector into another.
        """
    
        pass
    
    
    def transformAsNormal(*args, **kwargs):
        """
        Returns a new vector which is calculated by postmultiplying this vector by the transpose of the given matrix's inverse and then normalizing the result.
        """
    
        pass
    
    
    x = None
    
    y = None
    
    z = None
    
    __new__ = None
    
    
    kOneVector = None
    
    
    kTolerance = None
    
    
    kWaxis = None
    
    
    kXaxis = None
    
    
    kXaxisVector = None
    
    
    kXnegAxisVector = None
    
    
    kYaxis = None
    
    
    kYaxisVector = None
    
    
    kYnegAxisVector = None
    
    
    kZaxis = None
    
    
    kZaxisVector = None
    
    
    kZeroVector = None
    
    
    kZnegAxisVector = None


class MPoint(object):
    """
    3D point with double-precision coordinates.
    """
    
    
    
    def __add__(*args, **kwargs):
        """
        x.__add__(y) <==> x+y
        """
    
        pass
    
    
    def __delitem__(*args, **kwargs):
        """
        x.__delitem__(y) <==> del x[y]
        """
    
        pass
    
    
    def __div__(*args, **kwargs):
        """
        x.__div__(y) <==> x/y
        """
    
        pass
    
    
    def __eq__(*args, **kwargs):
        """
        x.__eq__(y) <==> x==y
        """
    
        pass
    
    
    def __ge__(*args, **kwargs):
        """
        x.__ge__(y) <==> x>=y
        """
    
        pass
    
    
    def __getitem__(*args, **kwargs):
        """
        x.__getitem__(y) <==> x[y]
        """
    
        pass
    
    
    def __gt__(*args, **kwargs):
        """
        x.__gt__(y) <==> x>y
        """
    
        pass
    
    
    def __iadd__(*args, **kwargs):
        """
        x.__iadd__(y) <==> x+y
        """
    
        pass
    
    
    def __imul__(*args, **kwargs):
        """
        x.__imul__(y) <==> x*y
        """
    
        pass
    
    
    def __init__(*args, **kwargs):
        """
        x.__init__(...) initializes x; see x.__class__.__doc__ for signature
        """
    
        pass
    
    
    def __isub__(*args, **kwargs):
        """
        x.__isub__(y) <==> x-y
        """
    
        pass
    
    
    def __le__(*args, **kwargs):
        """
        x.__le__(y) <==> x<=y
        """
    
        pass
    
    
    def __len__(*args, **kwargs):
        """
        x.__len__() <==> len(x)
        """
    
        pass
    
    
    def __lt__(*args, **kwargs):
        """
        x.__lt__(y) <==> x<y
        """
    
        pass
    
    
    def __mul__(*args, **kwargs):
        """
        x.__mul__(y) <==> x*y
        """
    
        pass
    
    
    def __ne__(*args, **kwargs):
        """
        x.__ne__(y) <==> x!=y
        """
    
        pass
    
    
    def __radd__(*args, **kwargs):
        """
        x.__radd__(y) <==> y+x
        """
    
        pass
    
    
    def __rdiv__(*args, **kwargs):
        """
        x.__rdiv__(y) <==> y/x
        """
    
        pass
    
    
    def __repr__(*args, **kwargs):
        """
        x.__repr__() <==> repr(x)
        """
    
        pass
    
    
    def __rmul__(*args, **kwargs):
        """
        x.__rmul__(y) <==> y*x
        """
    
        pass
    
    
    def __rsub__(*args, **kwargs):
        """
        x.__rsub__(y) <==> y-x
        """
    
        pass
    
    
    def __setitem__(*args, **kwargs):
        """
        x.__setitem__(i, y) <==> x[i]=y
        """
    
        pass
    
    
    def __str__(*args, **kwargs):
        """
        x.__str__() <==> str(x)
        """
    
        pass
    
    
    def __sub__(*args, **kwargs):
        """
        x.__sub__(y) <==> x-y
        """
    
        pass
    
    
    def cartesianize(*args, **kwargs):
        """
        Convert point to cartesian form.
        """
    
        pass
    
    
    def distanceTo(*args, **kwargs):
        """
        Return distance between this point and another.
        """
    
        pass
    
    
    def homogenize(*args, **kwargs):
        """
        Convert point to homogenous form.
        """
    
        pass
    
    
    def isEquivalent(*args, **kwargs):
        """
        Test for equivalence of two points, within a tolerance.
        """
    
        pass
    
    
    def rationalize(*args, **kwargs):
        """
        Convert point to rational form.
        """
    
        pass
    
    
    w = None
    
    x = None
    
    y = None
    
    z = None
    
    __new__ = None
    
    
    kOrigin = None
    
    
    kTolerance = None


class MFloatPointArray(object):
    """
    Array of MFloatPoint values.
    """
    
    
    
    def __add__(*args, **kwargs):
        """
        x.__add__(y) <==> x+y
        """
    
        pass
    
    
    def __contains__(*args, **kwargs):
        """
        x.__contains__(y) <==> y in x
        """
    
        pass
    
    
    def __delitem__(*args, **kwargs):
        """
        x.__delitem__(y) <==> del x[y]
        """
    
        pass
    
    
    def __getitem__(*args, **kwargs):
        """
        x.__getitem__(y) <==> x[y]
        """
    
        pass
    
    
    def __iadd__(*args, **kwargs):
        """
        x.__iadd__(y) <==> x+=y
        """
    
        pass
    
    
    def __imul__(*args, **kwargs):
        """
        x.__imul__(y) <==> x*=y
        """
    
        pass
    
    
    def __init__(*args, **kwargs):
        """
        x.__init__(...) initializes x; see x.__class__.__doc__ for signature
        """
    
        pass
    
    
    def __len__(*args, **kwargs):
        """
        x.__len__() <==> len(x)
        """
    
        pass
    
    
    def __mul__(*args, **kwargs):
        """
        x.__mul__(n) <==> x*n
        """
    
        pass
    
    
    def __repr__(*args, **kwargs):
        """
        x.__repr__() <==> repr(x)
        """
    
        pass
    
    
    def __rmul__(*args, **kwargs):
        """
        x.__rmul__(n) <==> n*x
        """
    
        pass
    
    
    def __setitem__(*args, **kwargs):
        """
        x.__setitem__(i, y) <==> x[i]=y
        """
    
        pass
    
    
    def __str__(*args, **kwargs):
        """
        x.__str__() <==> str(x)
        """
    
        pass
    
    
    def append(*args, **kwargs):
        """
        Add a value to the end of the array.
        """
    
        pass
    
    
    def clear(*args, **kwargs):
        """
        Remove all elements from the array.
        """
    
        pass
    
    
    def copy(*args, **kwargs):
        """
        Replace the array contents with that of another or of a compatible Python sequence.
        """
    
        pass
    
    
    def insert(*args, **kwargs):
        """
        Insert a new value into the array at the given index.
        """
    
        pass
    
    
    def remove(*args, **kwargs):
        """
        Remove an element from the array.
        """
    
        pass
    
    
    def setLength(*args, **kwargs):
        """
        Grow or shrink the array to contain a specific number of elements.
        """
    
        pass
    
    
    sizeIncrement = None
    
    __new__ = None


class MPlug(object):
    """
    Create and access dependency node plugs.
    """
    
    
    
    def __eq__(*args, **kwargs):
        """
        x.__eq__(y) <==> x==y
        """
    
        pass
    
    
    def __ge__(*args, **kwargs):
        """
        x.__ge__(y) <==> x>=y
        """
    
        pass
    
    
    def __gt__(*args, **kwargs):
        """
        x.__gt__(y) <==> x>y
        """
    
        pass
    
    
    def __init__(*args, **kwargs):
        """
        x.__init__(...) initializes x; see x.__class__.__doc__ for signature
        """
    
        pass
    
    
    def __le__(*args, **kwargs):
        """
        x.__le__(y) <==> x<=y
        """
    
        pass
    
    
    def __lt__(*args, **kwargs):
        """
        x.__lt__(y) <==> x<y
        """
    
        pass
    
    
    def __ne__(*args, **kwargs):
        """
        x.__ne__(y) <==> x!=y
        """
    
        pass
    
    
    def __str__(*args, **kwargs):
        """
        x.__str__() <==> str(x)
        """
    
        pass
    
    
    def array(*args, **kwargs):
        """
        Returns a plug for the array of plugs of which this plug is an element.
        """
    
        pass
    
    
    def asBool(*args, **kwargs):
        """
        Retrieves the plug's value, as a boolean.
        """
    
        pass
    
    
    def asChar(*args, **kwargs):
        """
        Retrieves the plug's value, as a single-byte integer.
        """
    
        pass
    
    
    def asDouble(*args, **kwargs):
        """
        Retrieves the plug's value, as a double-precision float.
        """
    
        pass
    
    
    def asFloat(*args, **kwargs):
        """
        Retrieves the plug's value, as a single-precision float.
        """
    
        pass
    
    
    def asInt(*args, **kwargs):
        """
        Retrieves the plug's value, as a regular integer.
        """
    
        pass
    
    
    def asMAngle(*args, **kwargs):
        """
        Retrieves the plug's value, as an MAngle.
        """
    
        pass
    
    
    def asMDistance(*args, **kwargs):
        """
        Retrieves the plug's value, as an MDistance.
        """
    
        pass
    
    
    def asMObject(*args, **kwargs):
        """
        Retrieves the plug's value, as as an MObject containing a direct reference to the plug's data.
        """
    
        pass
    
    
    def asMTime(*args, **kwargs):
        """
        Retrieves the plug's value, as an MTime.
        """
    
        pass
    
    
    def asShort(*args, **kwargs):
        """
        Retrieves the plug's value, as a short integer.
        """
    
        pass
    
    
    def asString(*args, **kwargs):
        """
        Retrieves the plug's value, as a string.
        """
    
        pass
    
    
    def attribute(*args, **kwargs):
        """
        Returns the attribute currently referenced by this plug.
        """
    
        pass
    
    
    def child(*args, **kwargs):
        """
        Returns a plug for the specified child attribute of this plug.
        """
    
        pass
    
    
    def connectedTo(*args, **kwargs):
        """
        Returns an array of plugs which are connected to this one.
        """
    
        pass
    
    
    def connectionByPhysicalIndex(*args, **kwargs):
        """
        Returns a plug for the index'th connected element of this plug.
        """
    
        pass
    
    
    def constructHandle(*args, **kwargs):
        """
        Constructs a data handle for the plug.
        """
    
        pass
    
    
    def destructHandle(*args, **kwargs):
        """
        Destroys a data handle previously constructed using constructHandle().
        """
    
        pass
    
    
    def elementByLogicalIndex(*args, **kwargs):
        """
        Returns a plug for the element of this plug array having the specified logical index.
        """
    
        pass
    
    
    def elementByPhysicalIndex(*args, **kwargs):
        """
        Returns a plug for the element of this plug array having the specified physical index.
        """
    
        pass
    
    
    def evaluateNumElements(*args, **kwargs):
        """
        Like numElements() but evaluates all connected elements first to ensure that they are included in the count.
        """
    
        pass
    
    
    def getExistingArrayAttributeIndices(*args, **kwargs):
        """
        Returns an array of all the plug's logical indices which are currently in use.
        """
    
        pass
    
    
    def getSetAttrCmds(*args, **kwargs):
        """
        Returns a list of strings containing the setAttr commands (in MEL syntax) for this plug and all of its descendents.
        """
    
        pass
    
    
    def isFreeToChange(*args, **kwargs):
        """
        Returns a value indicating if the plug's value can be changed, after taking into account the effects of locking and connections.
        """
    
        pass
    
    
    def logicalIndex(*args, **kwargs):
        """
        Returns this plug's logical index within its parent array.
        """
    
        pass
    
    
    def name(*args, **kwargs):
        """
        Returns the name of the plug.
        """
    
        pass
    
    
    def node(*args, **kwargs):
        """
        Returns the node that this plug belongs to.
        """
    
        pass
    
    
    def numChildren(*args, **kwargs):
        """
        Returns the number of children this plug has.
        """
    
        pass
    
    
    def numConnectedChildren(*args, **kwargs):
        """
        Returns the number of this plug's children which have connections.
        """
    
        pass
    
    
    def numConnectedElements(*args, **kwargs):
        """
        Returns the number of this plug's elements which have connections.
        """
    
        pass
    
    
    def numElements(*args, **kwargs):
        """
        Returns the number of the plug's logical indices which are currently in use. Connected elements which have not yet been evaluated may not yet fully exist and may be excluded from the count.
        """
    
        pass
    
    
    def parent(*args, **kwargs):
        """
        Returns a plug for the parent of this plug.
        """
    
        pass
    
    
    def partialName(*args, **kwargs):
        """
        Returns the name of the plug, formatted according to various criteria.
        """
    
        pass
    
    
    def selectAncestorLogicalIndex(*args, **kwargs):
        """
        Changes the logical index of the specified attribute in the plug's path.
        """
    
        pass
    
    
    def setAttribute(*args, **kwargs):
        """
        Switches the plug to reference the given attribute of the same node as the previously referenced attribute.
        """
    
        pass
    
    
    def setBool(*args, **kwargs):
        """
        Sets the plug's value as a boolean.
        """
    
        pass
    
    
    def setChar(*args, **kwargs):
        """
        Sets the plug's value as a single-byte integer.
        """
    
        pass
    
    
    def setDouble(*args, **kwargs):
        """
        Sets the plug's value as a double-precision float.
        """
    
        pass
    
    
    def setFloat(*args, **kwargs):
        """
        Sets the plug's value as a single-precision float.
        """
    
        pass
    
    
    def setInt(*args, **kwargs):
        """
        Sets the plug's value as a regular integer.
        """
    
        pass
    
    
    def setMAngle(*args, **kwargs):
        """
        Sets the plug's value as an MAngle.
        """
    
        pass
    
    
    def setMDataHandle(*args, **kwargs):
        """
        Sets the plug's value as a data handle.
        """
    
        pass
    
    
    def setMDistance(*args, **kwargs):
        """
        Sets the plug's value as an MDistance.
        """
    
        pass
    
    
    def setMObject(*args, **kwargs):
        """
        Sets the plug's value as an MObject.
        """
    
        pass
    
    
    def setMPxData(*args, **kwargs):
        """
        Sets the plug's value using custom plug-in data.
        """
    
        pass
    
    
    def setMTime(*args, **kwargs):
        """
        Sets the plug's value as an MTime.
        """
    
        pass
    
    
    def setNumElements(*args, **kwargs):
        """
        Pre-allocates space for count elements in an array of plugs.
        """
    
        pass
    
    
    def setShort(*args, **kwargs):
        """
        Sets the plug's value as a short integer.
        """
    
        pass
    
    
    def setString(*args, **kwargs):
        """
        Sets the plug's value as a string.
        """
    
        pass
    
    
    info = None
    
    isArray = None
    
    isCaching = None
    
    isChannelBox = None
    
    isChild = None
    
    isCompound = None
    
    isConnected = None
    
    isDestination = None
    
    isDynamic = None
    
    isElement = None
    
    isFromReferencedFile = None
    
    isIgnoredWhenRendering = None
    
    isKeyable = None
    
    isLocked = None
    
    isNetworked = None
    
    isNull = None
    
    isProcedural = None
    
    isSource = None
    
    __new__ = None
    
    
    kAll = None
    
    
    kChanged = None
    
    
    kChildrenNotFreeToChange = None
    
    
    kFreeToChange = None
    
    
    kLastAttrSelector = None
    
    
    kNonDefault = None
    
    
    kNotFreeToChange = None


class MFloatVectorArray(object):
    """
    Array of MFloatVector values.
    """
    
    
    
    def __add__(*args, **kwargs):
        """
        x.__add__(y) <==> x+y
        """
    
        pass
    
    
    def __contains__(*args, **kwargs):
        """
        x.__contains__(y) <==> y in x
        """
    
        pass
    
    
    def __delitem__(*args, **kwargs):
        """
        x.__delitem__(y) <==> del x[y]
        """
    
        pass
    
    
    def __getitem__(*args, **kwargs):
        """
        x.__getitem__(y) <==> x[y]
        """
    
        pass
    
    
    def __iadd__(*args, **kwargs):
        """
        x.__iadd__(y) <==> x+=y
        """
    
        pass
    
    
    def __imul__(*args, **kwargs):
        """
        x.__imul__(y) <==> x*=y
        """
    
        pass
    
    
    def __init__(*args, **kwargs):
        """
        x.__init__(...) initializes x; see x.__class__.__doc__ for signature
        """
    
        pass
    
    
    def __len__(*args, **kwargs):
        """
        x.__len__() <==> len(x)
        """
    
        pass
    
    
    def __mul__(*args, **kwargs):
        """
        x.__mul__(n) <==> x*n
        """
    
        pass
    
    
    def __repr__(*args, **kwargs):
        """
        x.__repr__() <==> repr(x)
        """
    
        pass
    
    
    def __rmul__(*args, **kwargs):
        """
        x.__rmul__(n) <==> n*x
        """
    
        pass
    
    
    def __setitem__(*args, **kwargs):
        """
        x.__setitem__(i, y) <==> x[i]=y
        """
    
        pass
    
    
    def __str__(*args, **kwargs):
        """
        x.__str__() <==> str(x)
        """
    
        pass
    
    
    def append(*args, **kwargs):
        """
        Add a value to the end of the array.
        """
    
        pass
    
    
    def clear(*args, **kwargs):
        """
        Remove all elements from the array.
        """
    
        pass
    
    
    def copy(*args, **kwargs):
        """
        Replace the array contents with that of another or of a compatible Python sequence.
        """
    
        pass
    
    
    def insert(*args, **kwargs):
        """
        Insert a new value into the array at the given index.
        """
    
        pass
    
    
    def remove(*args, **kwargs):
        """
        Remove an element from the array.
        """
    
        pass
    
    
    def setLength(*args, **kwargs):
        """
        Grow or shrink the array to contain a specific number of elements.
        """
    
        pass
    
    
    sizeIncrement = None
    
    __new__ = None


class MFnPlugin(object):
    """
    Register and deregister plug-in services with Maya.
    """
    
    
    
    def __init__(*args, **kwargs):
        """
        x.__init__(...) initializes x; see x.__class__.__doc__ for signature
        """
    
        pass
    
    
    def apiVersion(*args, **kwargs):
        """
        Return the API version required by the plug-in.
        """
    
        pass
    
    
    def deregisterCommand(*args, **kwargs):
        """
        Deregister a user defined command from Maya.
        """
    
        pass
    
    
    def loadPath(*args, **kwargs):
        """
        Return the full path name of the file from which the plug-in was loaded.
        """
    
        pass
    
    
    def name(*args, **kwargs):
        """
        Return the plug-in's name.
        """
    
        pass
    
    
    def registerCommand(*args, **kwargs):
        """
        Register a new command with Maya.
        """
    
        pass
    
    
    def setName(*args, **kwargs):
        """
        Set the plug-in's name.
        """
    
        pass
    
    
    def vendor(*args, **kwargs):
        """
        Return the plug-in's vendor string.
        """
    
        pass
    
    
    version = None
    
    __new__ = None


class MAngle(object):
    """
    Manipulate angular data.
    """
    
    
    
    def __init__(*args, **kwargs):
        """
        x.__init__(...) initializes x; see x.__class__.__doc__ for signature
        """
    
        pass
    
    
    def __repr__(*args, **kwargs):
        """
        x.__repr__() <==> repr(x)
        """
    
        pass
    
    
    def __str__(*args, **kwargs):
        """
        x.__str__() <==> str(x)
        """
    
        pass
    
    
    def asAngMinutes(*args, **kwargs):
        """
        Return the angular value, converted to minutes of arc.
        """
    
        pass
    
    
    def asAngSeconds(*args, **kwargs):
        """
        Return the angular value, converted to seconds of arc.
        """
    
        pass
    
    
    def asDegrees(*args, **kwargs):
        """
        Return the angular value, converted to degrees.
        """
    
        pass
    
    
    def asRadians(*args, **kwargs):
        """
        Return the angular value, converted to radians.
        """
    
        pass
    
    
    def asUnits(*args, **kwargs):
        """
        Return the angular value, converted to the specified units.
        """
    
        pass
    
    
    def internalToUI(*args, **kwargs):
        """
        Convert a value from Maya's internal units to the units used in the UI.
        """
    
        pass
    
    
    def internalUnit(*args, **kwargs):
        """
        Return the angular unit used internally by Maya.
        """
    
        pass
    
    
    def setUIUnit(*args, **kwargs):
        """
        Change the units used to display angles in Maya's UI.
        """
    
        pass
    
    
    def uiToInternal(*args, **kwargs):
        """
        Convert a value from the units used in the UI to Maya's internal units.
        """
    
        pass
    
    
    def uiUnit(*args, **kwargs):
        """
        Return the units used to display angles in Maya's UI.
        """
    
        pass
    
    
    unit = None
    
    value = None
    
    __new__ = None
    
    
    kAngMinutes = None
    
    
    kAngSeconds = None
    
    
    kDegrees = None
    
    
    kInvalid = None
    
    
    kLast = None
    
    
    kRadians = None


class MPointArray(object):
    """
    Array of MPoint values.
    """
    
    
    
    def __add__(*args, **kwargs):
        """
        x.__add__(y) <==> x+y
        """
    
        pass
    
    
    def __contains__(*args, **kwargs):
        """
        x.__contains__(y) <==> y in x
        """
    
        pass
    
    
    def __delitem__(*args, **kwargs):
        """
        x.__delitem__(y) <==> del x[y]
        """
    
        pass
    
    
    def __getitem__(*args, **kwargs):
        """
        x.__getitem__(y) <==> x[y]
        """
    
        pass
    
    
    def __iadd__(*args, **kwargs):
        """
        x.__iadd__(y) <==> x+=y
        """
    
        pass
    
    
    def __imul__(*args, **kwargs):
        """
        x.__imul__(y) <==> x*=y
        """
    
        pass
    
    
    def __init__(*args, **kwargs):
        """
        x.__init__(...) initializes x; see x.__class__.__doc__ for signature
        """
    
        pass
    
    
    def __len__(*args, **kwargs):
        """
        x.__len__() <==> len(x)
        """
    
        pass
    
    
    def __mul__(*args, **kwargs):
        """
        x.__mul__(n) <==> x*n
        """
    
        pass
    
    
    def __repr__(*args, **kwargs):
        """
        x.__repr__() <==> repr(x)
        """
    
        pass
    
    
    def __rmul__(*args, **kwargs):
        """
        x.__rmul__(n) <==> n*x
        """
    
        pass
    
    
    def __setitem__(*args, **kwargs):
        """
        x.__setitem__(i, y) <==> x[i]=y
        """
    
        pass
    
    
    def __str__(*args, **kwargs):
        """
        x.__str__() <==> str(x)
        """
    
        pass
    
    
    def append(*args, **kwargs):
        """
        Add a value to the end of the array.
        """
    
        pass
    
    
    def clear(*args, **kwargs):
        """
        Remove all elements from the array.
        """
    
        pass
    
    
    def copy(*args, **kwargs):
        """
        Replace the array contents with that of another or of a compatible Python sequence.
        """
    
        pass
    
    
    def insert(*args, **kwargs):
        """
        Insert a new value into the array at the given index.
        """
    
        pass
    
    
    def remove(*args, **kwargs):
        """
        Remove an element from the array.
        """
    
        pass
    
    
    def setLength(*args, **kwargs):
        """
        Grow or shrink the array to contain a specific number of elements.
        """
    
        pass
    
    
    sizeIncrement = None
    
    __new__ = None


class MObjectArray(object):
    """
    Array of MObject values.
    """
    
    
    
    def __add__(*args, **kwargs):
        """
        x.__add__(y) <==> x+y
        """
    
        pass
    
    
    def __contains__(*args, **kwargs):
        """
        x.__contains__(y) <==> y in x
        """
    
        pass
    
    
    def __delitem__(*args, **kwargs):
        """
        x.__delitem__(y) <==> del x[y]
        """
    
        pass
    
    
    def __getitem__(*args, **kwargs):
        """
        x.__getitem__(y) <==> x[y]
        """
    
        pass
    
    
    def __iadd__(*args, **kwargs):
        """
        x.__iadd__(y) <==> x+=y
        """
    
        pass
    
    
    def __imul__(*args, **kwargs):
        """
        x.__imul__(y) <==> x*=y
        """
    
        pass
    
    
    def __init__(*args, **kwargs):
        """
        x.__init__(...) initializes x; see x.__class__.__doc__ for signature
        """
    
        pass
    
    
    def __len__(*args, **kwargs):
        """
        x.__len__() <==> len(x)
        """
    
        pass
    
    
    def __mul__(*args, **kwargs):
        """
        x.__mul__(n) <==> x*n
        """
    
        pass
    
    
    def __repr__(*args, **kwargs):
        """
        x.__repr__() <==> repr(x)
        """
    
        pass
    
    
    def __rmul__(*args, **kwargs):
        """
        x.__rmul__(n) <==> n*x
        """
    
        pass
    
    
    def __setitem__(*args, **kwargs):
        """
        x.__setitem__(i, y) <==> x[i]=y
        """
    
        pass
    
    
    def __str__(*args, **kwargs):
        """
        x.__str__() <==> str(x)
        """
    
        pass
    
    
    def append(*args, **kwargs):
        """
        Add a value to the end of the array.
        """
    
        pass
    
    
    def clear(*args, **kwargs):
        """
        Remove all elements from the array.
        """
    
        pass
    
    
    def copy(*args, **kwargs):
        """
        Replace the array contents with that of another or of a compatible Python sequence.
        """
    
        pass
    
    
    def insert(*args, **kwargs):
        """
        Insert a new value into the array at the given index.
        """
    
        pass
    
    
    def remove(*args, **kwargs):
        """
        Remove an element from the array.
        """
    
        pass
    
    
    def setLength(*args, **kwargs):
        """
        Grow or shrink the array to contain a specific number of elements.
        """
    
        pass
    
    
    sizeIncrement = None
    
    __new__ = None


class MRampAttribute(object):
    """
    Functionset for creating and working with ramp attributes.
    """
    
    
    
    def __init__(*args, **kwargs):
        """
        x.__init__(...) initializes x; see x.__class__.__doc__ for signature
        """
    
        pass
    
    
    def addEntries(*args, **kwargs):
        """
        Adds entries to the ramp.
        """
    
        pass
    
    
    def deleteEntries(*args, **kwargs):
        """
        Removes from the ramp those entries with the specified indices.
        """
    
        pass
    
    
    def getEntries(*args, **kwargs):
        """
        Returns a tuple containing all of the entries in the ramp.
        """
    
        pass
    
    
    def getValueAtPosition(*args, **kwargs):
        """
        Returns the value of the entry at the given position.
        """
    
        pass
    
    
    def numEntries(*args, **kwargs):
        """
        Returns the number of entries in the ramp.
        """
    
        pass
    
    
    def setInterpolationAtIndex(*args, **kwargs):
        """
        Sets the interpolation of the entry at the given index.
        """
    
        pass
    
    
    def setPositionAtIndex(*args, **kwargs):
        """
        Sets the position of the entry at the given index.
        """
    
        pass
    
    
    def setValueAtIndex(*args, **kwargs):
        """
        Sets the value of the entry at the given index.
        """
    
        pass
    
    
    def createColorRamp(*args, **kwargs):
        """
        Creates and returns a new color ramp attribute.
        """
    
        pass
    
    
    def createCurveRamp(*args, **kwargs):
        """
        Creates and returns a new curve ramp attribute.
        """
    
        pass
    
    
    isColorRamp = None
    
    isCurveRamp = None
    
    __new__ = None
    
    
    kLinear = None
    
    
    kNone = None
    
    
    kSmooth = None
    
    
    kSpline = None


class MFloatPoint(object):
    """
    3D point with single-precision coordinates.
    """
    
    
    
    def __add__(*args, **kwargs):
        """
        x.__add__(y) <==> x+y
        """
    
        pass
    
    
    def __delitem__(*args, **kwargs):
        """
        x.__delitem__(y) <==> del x[y]
        """
    
        pass
    
    
    def __div__(*args, **kwargs):
        """
        x.__div__(y) <==> x/y
        """
    
        pass
    
    
    def __eq__(*args, **kwargs):
        """
        x.__eq__(y) <==> x==y
        """
    
        pass
    
    
    def __ge__(*args, **kwargs):
        """
        x.__ge__(y) <==> x>=y
        """
    
        pass
    
    
    def __getitem__(*args, **kwargs):
        """
        x.__getitem__(y) <==> x[y]
        """
    
        pass
    
    
    def __gt__(*args, **kwargs):
        """
        x.__gt__(y) <==> x>y
        """
    
        pass
    
    
    def __iadd__(*args, **kwargs):
        """
        x.__iadd__(y) <==> x+y
        """
    
        pass
    
    
    def __imul__(*args, **kwargs):
        """
        x.__imul__(y) <==> x*y
        """
    
        pass
    
    
    def __init__(*args, **kwargs):
        """
        x.__init__(...) initializes x; see x.__class__.__doc__ for signature
        """
    
        pass
    
    
    def __isub__(*args, **kwargs):
        """
        x.__isub__(y) <==> x-y
        """
    
        pass
    
    
    def __le__(*args, **kwargs):
        """
        x.__le__(y) <==> x<=y
        """
    
        pass
    
    
    def __len__(*args, **kwargs):
        """
        x.__len__() <==> len(x)
        """
    
        pass
    
    
    def __lt__(*args, **kwargs):
        """
        x.__lt__(y) <==> x<y
        """
    
        pass
    
    
    def __mul__(*args, **kwargs):
        """
        x.__mul__(y) <==> x*y
        """
    
        pass
    
    
    def __ne__(*args, **kwargs):
        """
        x.__ne__(y) <==> x!=y
        """
    
        pass
    
    
    def __radd__(*args, **kwargs):
        """
        x.__radd__(y) <==> y+x
        """
    
        pass
    
    
    def __rdiv__(*args, **kwargs):
        """
        x.__rdiv__(y) <==> y/x
        """
    
        pass
    
    
    def __repr__(*args, **kwargs):
        """
        x.__repr__() <==> repr(x)
        """
    
        pass
    
    
    def __rmul__(*args, **kwargs):
        """
        x.__rmul__(y) <==> y*x
        """
    
        pass
    
    
    def __rsub__(*args, **kwargs):
        """
        x.__rsub__(y) <==> y-x
        """
    
        pass
    
    
    def __setitem__(*args, **kwargs):
        """
        x.__setitem__(i, y) <==> x[i]=y
        """
    
        pass
    
    
    def __str__(*args, **kwargs):
        """
        x.__str__() <==> str(x)
        """
    
        pass
    
    
    def __sub__(*args, **kwargs):
        """
        x.__sub__(y) <==> x-y
        """
    
        pass
    
    
    def cartesianize(*args, **kwargs):
        """
        Convert point to cartesian form.
        """
    
        pass
    
    
    def distanceTo(*args, **kwargs):
        """
        Return distance between this point and another.
        """
    
        pass
    
    
    def homogenize(*args, **kwargs):
        """
        Convert point to homogenous form.
        """
    
        pass
    
    
    def isEquivalent(*args, **kwargs):
        """
        Test for equivalence of two points, within a tolerance.
        """
    
        pass
    
    
    def rationalize(*args, **kwargs):
        """
        Convert point to rational form.
        """
    
        pass
    
    
    w = None
    
    x = None
    
    y = None
    
    z = None
    
    __new__ = None
    
    
    kOrigin = None
    
    
    kTolerance = None


class MFloatVector(object):
    """
    3D vector with single-precision coordinates.
    """
    
    
    
    def __add__(*args, **kwargs):
        """
        x.__add__(y) <==> x+y
        """
    
        pass
    
    
    def __delitem__(*args, **kwargs):
        """
        x.__delitem__(y) <==> del x[y]
        """
    
        pass
    
    
    def __div__(*args, **kwargs):
        """
        x.__div__(y) <==> x/y
        """
    
        pass
    
    
    def __eq__(*args, **kwargs):
        """
        x.__eq__(y) <==> x==y
        """
    
        pass
    
    
    def __ge__(*args, **kwargs):
        """
        x.__ge__(y) <==> x>=y
        """
    
        pass
    
    
    def __getitem__(*args, **kwargs):
        """
        x.__getitem__(y) <==> x[y]
        """
    
        pass
    
    
    def __gt__(*args, **kwargs):
        """
        x.__gt__(y) <==> x>y
        """
    
        pass
    
    
    def __iadd__(*args, **kwargs):
        """
        x.__iadd__(y) <==> x+y
        """
    
        pass
    
    
    def __idiv__(*args, **kwargs):
        """
        x.__idiv__(y) <==> x/y
        """
    
        pass
    
    
    def __imul__(*args, **kwargs):
        """
        x.__imul__(y) <==> x*y
        """
    
        pass
    
    
    def __init__(*args, **kwargs):
        """
        x.__init__(...) initializes x; see x.__class__.__doc__ for signature
        """
    
        pass
    
    
    def __isub__(*args, **kwargs):
        """
        x.__isub__(y) <==> x-y
        """
    
        pass
    
    
    def __le__(*args, **kwargs):
        """
        x.__le__(y) <==> x<=y
        """
    
        pass
    
    
    def __len__(*args, **kwargs):
        """
        x.__len__() <==> len(x)
        """
    
        pass
    
    
    def __lt__(*args, **kwargs):
        """
        x.__lt__(y) <==> x<y
        """
    
        pass
    
    
    def __mul__(*args, **kwargs):
        """
        x.__mul__(y) <==> x*y
        """
    
        pass
    
    
    def __ne__(*args, **kwargs):
        """
        x.__ne__(y) <==> x!=y
        """
    
        pass
    
    
    def __neg__(*args, **kwargs):
        """
        x.__neg__() <==> -x
        """
    
        pass
    
    
    def __radd__(*args, **kwargs):
        """
        x.__radd__(y) <==> y+x
        """
    
        pass
    
    
    def __rdiv__(*args, **kwargs):
        """
        x.__rdiv__(y) <==> y/x
        """
    
        pass
    
    
    def __repr__(*args, **kwargs):
        """
        x.__repr__() <==> repr(x)
        """
    
        pass
    
    
    def __rmul__(*args, **kwargs):
        """
        x.__rmul__(y) <==> y*x
        """
    
        pass
    
    
    def __rsub__(*args, **kwargs):
        """
        x.__rsub__(y) <==> y-x
        """
    
        pass
    
    
    def __rxor__(*args, **kwargs):
        """
        x.__rxor__(y) <==> y^x
        """
    
        pass
    
    
    def __setitem__(*args, **kwargs):
        """
        x.__setitem__(i, y) <==> x[i]=y
        """
    
        pass
    
    
    def __str__(*args, **kwargs):
        """
        x.__str__() <==> str(x)
        """
    
        pass
    
    
    def __sub__(*args, **kwargs):
        """
        x.__sub__(y) <==> x-y
        """
    
        pass
    
    
    def __xor__(*args, **kwargs):
        """
        x.__xor__(y) <==> x^y
        """
    
        pass
    
    
    def angle(*args, **kwargs):
        """
        Returns the angle, in radians, between this vector and another.
        """
    
        pass
    
    
    def isEquivalent(*args, **kwargs):
        """
        Returns True if this vector and another are within a given tolerance of being equal.
        """
    
        pass
    
    
    def isParallel(*args, **kwargs):
        """
        Returns True if this vector and another are within the given tolerance of being parallel.
        """
    
        pass
    
    
    def length(*args, **kwargs):
        """
        Returns the magnitude of this vector.
        """
    
        pass
    
    
    def normal(*args, **kwargs):
        """
        Returns a new vector containing the normalized version of this one.
        """
    
        pass
    
    
    def normalize(*args, **kwargs):
        """
        Normalizes this vector in-place and returns a new reference to it.
        """
    
        pass
    
    
    def transformAsNormal(*args, **kwargs):
        """
        Returns a new vector which is calculated by postmultiplying this vector by the transpose of the given matrix and then normalizing the result.
        """
    
        pass
    
    
    x = None
    
    y = None
    
    z = None
    
    __new__ = None
    
    
    kOneVector = None
    
    
    kTolerance = None
    
    
    kXaxisVector = None
    
    
    kXnegAxisVector = None
    
    
    kYaxisVector = None
    
    
    kYnegAxisVector = None
    
    
    kZaxisVector = None
    
    
    kZeroVector = None
    
    
    kZnegAxisVector = None


class MVectorArray(object):
    """
    Array of MVector values.
    """
    
    
    
    def __add__(*args, **kwargs):
        """
        x.__add__(y) <==> x+y
        """
    
        pass
    
    
    def __contains__(*args, **kwargs):
        """
        x.__contains__(y) <==> y in x
        """
    
        pass
    
    
    def __delitem__(*args, **kwargs):
        """
        x.__delitem__(y) <==> del x[y]
        """
    
        pass
    
    
    def __getitem__(*args, **kwargs):
        """
        x.__getitem__(y) <==> x[y]
        """
    
        pass
    
    
    def __iadd__(*args, **kwargs):
        """
        x.__iadd__(y) <==> x+=y
        """
    
        pass
    
    
    def __imul__(*args, **kwargs):
        """
        x.__imul__(y) <==> x*=y
        """
    
        pass
    
    
    def __init__(*args, **kwargs):
        """
        x.__init__(...) initializes x; see x.__class__.__doc__ for signature
        """
    
        pass
    
    
    def __len__(*args, **kwargs):
        """
        x.__len__() <==> len(x)
        """
    
        pass
    
    
    def __mul__(*args, **kwargs):
        """
        x.__mul__(n) <==> x*n
        """
    
        pass
    
    
    def __repr__(*args, **kwargs):
        """
        x.__repr__() <==> repr(x)
        """
    
        pass
    
    
    def __rmul__(*args, **kwargs):
        """
        x.__rmul__(n) <==> n*x
        """
    
        pass
    
    
    def __setitem__(*args, **kwargs):
        """
        x.__setitem__(i, y) <==> x[i]=y
        """
    
        pass
    
    
    def __str__(*args, **kwargs):
        """
        x.__str__() <==> str(x)
        """
    
        pass
    
    
    def append(*args, **kwargs):
        """
        Add a value to the end of the array.
        """
    
        pass
    
    
    def clear(*args, **kwargs):
        """
        Remove all elements from the array.
        """
    
        pass
    
    
    def copy(*args, **kwargs):
        """
        Replace the array contents with that of another or of a compatible Python sequence.
        """
    
        pass
    
    
    def insert(*args, **kwargs):
        """
        Insert a new value into the array at the given index.
        """
    
        pass
    
    
    def remove(*args, **kwargs):
        """
        Remove an element from the array.
        """
    
        pass
    
    
    def setLength(*args, **kwargs):
        """
        Grow or shrink the array to contain a specific number of elements.
        """
    
        pass
    
    
    sizeIncrement = None
    
    __new__ = None


class MCallbackIdArray(object):
    """
    Array of MCallbackId values.
    """
    
    
    
    def __add__(*args, **kwargs):
        """
        x.__add__(y) <==> x+y
        """
    
        pass
    
    
    def __contains__(*args, **kwargs):
        """
        x.__contains__(y) <==> y in x
        """
    
        pass
    
    
    def __delitem__(*args, **kwargs):
        """
        x.__delitem__(y) <==> del x[y]
        """
    
        pass
    
    
    def __getitem__(*args, **kwargs):
        """
        x.__getitem__(y) <==> x[y]
        """
    
        pass
    
    
    def __iadd__(*args, **kwargs):
        """
        x.__iadd__(y) <==> x+=y
        """
    
        pass
    
    
    def __imul__(*args, **kwargs):
        """
        x.__imul__(y) <==> x*=y
        """
    
        pass
    
    
    def __init__(*args, **kwargs):
        """
        x.__init__(...) initializes x; see x.__class__.__doc__ for signature
        """
    
        pass
    
    
    def __len__(*args, **kwargs):
        """
        x.__len__() <==> len(x)
        """
    
        pass
    
    
    def __mul__(*args, **kwargs):
        """
        x.__mul__(n) <==> x*n
        """
    
        pass
    
    
    def __repr__(*args, **kwargs):
        """
        x.__repr__() <==> repr(x)
        """
    
        pass
    
    
    def __rmul__(*args, **kwargs):
        """
        x.__rmul__(n) <==> n*x
        """
    
        pass
    
    
    def __setitem__(*args, **kwargs):
        """
        x.__setitem__(i, y) <==> x[i]=y
        """
    
        pass
    
    
    def __str__(*args, **kwargs):
        """
        x.__str__() <==> str(x)
        """
    
        pass
    
    
    def append(*args, **kwargs):
        """
        Add a value to the end of the array.
        """
    
        pass
    
    
    def clear(*args, **kwargs):
        """
        Remove all elements from the array.
        """
    
        pass
    
    
    def copy(*args, **kwargs):
        """
        Replace the array contents with that of another or of a compatible Python sequence.
        """
    
        pass
    
    
    def insert(*args, **kwargs):
        """
        Insert a new value into the array at the given index.
        """
    
        pass
    
    
    def remove(*args, **kwargs):
        """
        Remove an element from the array.
        """
    
        pass
    
    
    def setLength(*args, **kwargs):
        """
        Grow or shrink the array to contain a specific number of elements.
        """
    
        pass
    
    
    sizeIncrement = None
    
    __new__ = None


class MSelectionList(object):
    """
    A heterogenous list of MObjects, MPlugs and MDagPaths.
    """
    
    
    
    def __init__(*args, **kwargs):
        """
        x.__init__(...) initializes x; see x.__class__.__doc__ for signature
        """
    
        pass
    
    
    def __len__(*args, **kwargs):
        """
        x.__len__() <==> len(x)
        """
    
        pass
    
    
    def add(*args, **kwargs):
        """
        Adds a node, DAG path or component to the selection list.
        """
    
        pass
    
    
    def getDagPath(*args, **kwargs):
        """
        Retrieves a dag path and (possible null) component from the list and returns them in a tuple.
        """
    
        pass
    
    
    def getDependNode(*args, **kwargs):
        """
        Retrieves a dependency node from the list.
        """
    
        pass
    
    
    def getPlug(*args, **kwargs):
        """
        Retrieves a plug from the list.
        """
    
        pass
    
    
    __new__ = None
    
    
    kMergeNormal = None
    
    
    kRemoveFromList = None
    
    
    kXORWithList = None


class MObject(object):
    """
    Opaque wrapper for internal Maya objects.
    """
    
    
    
    def __eq__(*args, **kwargs):
        """
        x.__eq__(y) <==> x==y
        """
    
        pass
    
    
    def __ge__(*args, **kwargs):
        """
        x.__ge__(y) <==> x>=y
        """
    
        pass
    
    
    def __gt__(*args, **kwargs):
        """
        x.__gt__(y) <==> x>y
        """
    
        pass
    
    
    def __init__(*args, **kwargs):
        """
        x.__init__(...) initializes x; see x.__class__.__doc__ for signature
        """
    
        pass
    
    
    def __le__(*args, **kwargs):
        """
        x.__le__(y) <==> x<=y
        """
    
        pass
    
    
    def __lt__(*args, **kwargs):
        """
        x.__lt__(y) <==> x<y
        """
    
        pass
    
    
    def __ne__(*args, **kwargs):
        """
        x.__ne__(y) <==> x!=y
        """
    
        pass
    
    
    def apiType(*args, **kwargs):
        """
        Returns the function set type for the object.
        """
    
        pass
    
    
    def hasFn(*args, **kwargs):
        """
        Tests whether object is compatible with the specified function set.
        """
    
        pass
    
    
    def isNull(*args, **kwargs):
        """
        Tests whether there is an internal Maya object.
        """
    
        pass
    
    
    apiTypeStr = None
    
    __new__ = None
    
    
    kNullObj = None


class MDagPathArray(object):
    """
    Array of MDagPath values.
    """
    
    
    
    def __add__(*args, **kwargs):
        """
        x.__add__(y) <==> x+y
        """
    
        pass
    
    
    def __contains__(*args, **kwargs):
        """
        x.__contains__(y) <==> y in x
        """
    
        pass
    
    
    def __delitem__(*args, **kwargs):
        """
        x.__delitem__(y) <==> del x[y]
        """
    
        pass
    
    
    def __getitem__(*args, **kwargs):
        """
        x.__getitem__(y) <==> x[y]
        """
    
        pass
    
    
    def __iadd__(*args, **kwargs):
        """
        x.__iadd__(y) <==> x+=y
        """
    
        pass
    
    
    def __imul__(*args, **kwargs):
        """
        x.__imul__(y) <==> x*=y
        """
    
        pass
    
    
    def __init__(*args, **kwargs):
        """
        x.__init__(...) initializes x; see x.__class__.__doc__ for signature
        """
    
        pass
    
    
    def __len__(*args, **kwargs):
        """
        x.__len__() <==> len(x)
        """
    
        pass
    
    
    def __mul__(*args, **kwargs):
        """
        x.__mul__(n) <==> x*n
        """
    
        pass
    
    
    def __repr__(*args, **kwargs):
        """
        x.__repr__() <==> repr(x)
        """
    
        pass
    
    
    def __rmul__(*args, **kwargs):
        """
        x.__rmul__(n) <==> n*x
        """
    
        pass
    
    
    def __setitem__(*args, **kwargs):
        """
        x.__setitem__(i, y) <==> x[i]=y
        """
    
        pass
    
    
    def __str__(*args, **kwargs):
        """
        x.__str__() <==> str(x)
        """
    
        pass
    
    
    def append(*args, **kwargs):
        """
        Add a value to the end of the array.
        """
    
        pass
    
    
    def clear(*args, **kwargs):
        """
        Remove all elements from the array.
        """
    
        pass
    
    
    def copy(*args, **kwargs):
        """
        Replace the array contents with that of another or of a compatible Python sequence.
        """
    
        pass
    
    
    def insert(*args, **kwargs):
        """
        Insert a new value into the array at the given index.
        """
    
        pass
    
    
    def remove(*args, **kwargs):
        """
        Remove an element from the array.
        """
    
        pass
    
    
    def setLength(*args, **kwargs):
        """
        Grow or shrink the array to contain a specific number of elements.
        """
    
        pass
    
    
    sizeIncrement = None
    
    __new__ = None


class MTransformationMatrix(object):
    """
    Manipulate the individual components of a transformation.
    """
    
    
    
    def __eq__(*args, **kwargs):
        """
        x.__eq__(y) <==> x==y
        """
    
        pass
    
    
    def __ge__(*args, **kwargs):
        """
        x.__ge__(y) <==> x>=y
        """
    
        pass
    
    
    def __gt__(*args, **kwargs):
        """
        x.__gt__(y) <==> x>y
        """
    
        pass
    
    
    def __init__(*args, **kwargs):
        """
        x.__init__(...) initializes x; see x.__class__.__doc__ for signature
        """
    
        pass
    
    
    def __le__(*args, **kwargs):
        """
        x.__le__(y) <==> x<=y
        """
    
        pass
    
    
    def __lt__(*args, **kwargs):
        """
        x.__lt__(y) <==> x<y
        """
    
        pass
    
    
    def __ne__(*args, **kwargs):
        """
        x.__ne__(y) <==> x!=y
        """
    
        pass
    
    
    def asMatrix(*args, **kwargs):
        """
        Interpolates between the identity transformation and that currently in the object, returning the result as an MMatrix.
        """
    
        pass
    
    
    def asMatrixInverse(*args, **kwargs):
        """
        Returns the inverse of the matrix representing the transformation.
        """
    
        pass
    
    
    def asRotateMatrix(*args, **kwargs):
        """
        Returns the matrix which takes points from object space to the space immediately following the scale/shear/rotation transformations.
        """
    
        pass
    
    
    def asScaleMatrix(*args, **kwargs):
        """
        Returns the matrix which takes points from object space to the space immediately following scale and shear transformations.
        """
    
        pass
    
    
    def isEquivalent(*args, **kwargs):
        """
        Returns true if this transformation's matrix is within tolerance of another's matrix.
        """
    
        pass
    
    
    def reorderRotation(*args, **kwargs):
        """
        Reorders the transformation's rotate component to give the same overall rotation but using a new order or rotations.
        """
    
        pass
    
    
    def rotateBy(*args, **kwargs):
        """
        Adds to the transformation's rotation component.
        """
    
        pass
    
    
    def rotateByComponents(*args, **kwargs):
        """
        Adds to the transformation's rotation component.
        """
    
        pass
    
    
    def rotatePivot(*args, **kwargs):
        """
        Returns the transformation's rotate pivot component.
        """
    
        pass
    
    
    def rotatePivotTranslation(*args, **kwargs):
        """
        Returns the transformation's rotate pivot translation component.
        """
    
        pass
    
    
    def rotation(*args, **kwargs):
        """
        Returns the transformation's rotation component as either an Euler rotation or a quaternion.
        """
    
        pass
    
    
    def rotationComponents(*args, **kwargs):
        """
        Returns a list containing the four components of the transformation's rotate component.
        """
    
        pass
    
    
    def rotationOrder(*args, **kwargs):
        """
        Returns the order of rotations when the transformation's rotate component is expressed as an euler rotation.
        """
    
        pass
    
    
    def rotationOrientation(*args, **kwargs):
        """
        Returns a quaternion which orients the local rotation space.
        """
    
        pass
    
    
    def scale(*args, **kwargs):
        """
        Returns a list containing the transformation's scale components.
        """
    
        pass
    
    
    def scaleBy(*args, **kwargs):
        """
        Multiplies the transformation's scale components by the three floats in the provided sequence.
        """
    
        pass
    
    
    def scalePivot(*args, **kwargs):
        """
        Returns the transformation's scale pivot component.
        """
    
        pass
    
    
    def scalePivotTranslation(*args, **kwargs):
        """
        Returns the transformation's scale pivot translation component.
        """
    
        pass
    
    
    def setRotatePivot(*args, **kwargs):
        """
        Sets the transformation's rotate pivot component.
        """
    
        pass
    
    
    def setRotatePivotTranslation(*args, **kwargs):
        """
        Sets the transformation's rotate pivot translation component.
        """
    
        pass
    
    
    def setRotation(*args, **kwargs):
        """
        Sets the transformation's rotation component.
        """
    
        pass
    
    
    def setRotationComponents(*args, **kwargs):
        """
        Sets the transformation's rotate component from the four values in the provided sequence.
        """
    
        pass
    
    
    def setRotationOrientation(*args, **kwargs):
        """
        Sets a quaternion which orients the local rotation space.
        """
    
        pass
    
    
    def setScale(*args, **kwargs):
        """
        Sets the transformation's scale components to the three floats in the provided sequence.
        """
    
        pass
    
    
    def setScalePivot(*args, **kwargs):
        """
        Sets the transformation's scale pivot component.
        """
    
        pass
    
    
    def setScalePivotTranslation(*args, **kwargs):
        """
        Sets the transformation's scale pivot translation component.
        """
    
        pass
    
    
    def setShear(*args, **kwargs):
        """
        Sets the transformation's shear component.
        """
    
        pass
    
    
    def setToRotationAxis(*args, **kwargs):
        """
        Sets the transformation's rotate component to be a given axis vector and angle in radians.
        """
    
        pass
    
    
    def setTranslation(*args, **kwargs):
        """
        Sets the transformation's translation component.
        """
    
        pass
    
    
    def shear(*args, **kwargs):
        """
        Returns a list containing the transformation's shear components.
        """
    
        pass
    
    
    def shearBy(*args, **kwargs):
        """
        Multiplies the transformation's shear components by the three floats in the provided sequence.
        """
    
        pass
    
    
    def translateBy(*args, **kwargs):
        """
        Adds a vector to the transformation's translation component.
        """
    
        pass
    
    
    def translation(*args, **kwargs):
        """
        Returns the transformation's translation component as a vector.
        """
    
        pass
    
    
    __new__ = None
    
    
    kIdentity = None
    
    
    kInvalid = None
    
    
    kLast = None
    
    
    kTolerance = None
    
    
    kXYZ = None
    
    
    kXZY = None
    
    
    kYXZ = None
    
    
    kYZX = None
    
    
    kZXY = None
    
    
    kZYX = None


class MQuaternion(object):
    """
    Quaternion math.
    """
    
    
    
    def __add__(*args, **kwargs):
        """
        x.__add__(y) <==> x+y
        """
    
        pass
    
    
    def __delitem__(*args, **kwargs):
        """
        x.__delitem__(y) <==> del x[y]
        """
    
        pass
    
    
    def __eq__(*args, **kwargs):
        """
        x.__eq__(y) <==> x==y
        """
    
        pass
    
    
    def __ge__(*args, **kwargs):
        """
        x.__ge__(y) <==> x>=y
        """
    
        pass
    
    
    def __getitem__(*args, **kwargs):
        """
        x.__getitem__(y) <==> x[y]
        """
    
        pass
    
    
    def __gt__(*args, **kwargs):
        """
        x.__gt__(y) <==> x>y
        """
    
        pass
    
    
    def __imul__(*args, **kwargs):
        """
        x.__imul__(y) <==> x*y
        """
    
        pass
    
    
    def __init__(*args, **kwargs):
        """
        x.__init__(...) initializes x; see x.__class__.__doc__ for signature
        """
    
        pass
    
    
    def __le__(*args, **kwargs):
        """
        x.__le__(y) <==> x<=y
        """
    
        pass
    
    
    def __len__(*args, **kwargs):
        """
        x.__len__() <==> len(x)
        """
    
        pass
    
    
    def __lt__(*args, **kwargs):
        """
        x.__lt__(y) <==> x<y
        """
    
        pass
    
    
    def __mul__(*args, **kwargs):
        """
        x.__mul__(y) <==> x*y
        """
    
        pass
    
    
    def __ne__(*args, **kwargs):
        """
        x.__ne__(y) <==> x!=y
        """
    
        pass
    
    
    def __neg__(*args, **kwargs):
        """
        x.__neg__() <==> -x
        """
    
        pass
    
    
    def __radd__(*args, **kwargs):
        """
        x.__radd__(y) <==> y+x
        """
    
        pass
    
    
    def __repr__(*args, **kwargs):
        """
        x.__repr__() <==> repr(x)
        """
    
        pass
    
    
    def __rmul__(*args, **kwargs):
        """
        x.__rmul__(y) <==> y*x
        """
    
        pass
    
    
    def __rsub__(*args, **kwargs):
        """
        x.__rsub__(y) <==> y-x
        """
    
        pass
    
    
    def __setitem__(*args, **kwargs):
        """
        x.__setitem__(i, y) <==> x[i]=y
        """
    
        pass
    
    
    def __str__(*args, **kwargs):
        """
        x.__str__() <==> str(x)
        """
    
        pass
    
    
    def __sub__(*args, **kwargs):
        """
        x.__sub__(y) <==> x-y
        """
    
        pass
    
    
    def asAxisAngle(*args, **kwargs):
        """
        Returns the rotation as a tuple containing an axis vector and an angle in radians about that axis.
        """
    
        pass
    
    
    def asEulerRotation(*args, **kwargs):
        """
        Returns the rotation as an equivalent MEulerRotation.
        """
    
        pass
    
    
    def asMatrix(*args, **kwargs):
        """
        Returns the rotation as an equivalent rotation matrix.
        """
    
        pass
    
    
    def conjugate(*args, **kwargs):
        """
        Returns the conjugate of this quaternion (i.e. x, y and z components negated).
        """
    
        pass
    
    
    def conjugateIt(*args, **kwargs):
        """
        In-place conjugation (i.e. negates the x, y and z components).
        """
    
        pass
    
    
    def exp(*args, **kwargs):
        """
        Returns a new quaternion containing the exponent of this one.
        """
    
        pass
    
    
    def inverse(*args, **kwargs):
        """
        Returns a new quaternion containing the inverse of this one.
        """
    
        pass
    
    
    def invertIt(*args, **kwargs):
        """
        In-place inversion.
        """
    
        pass
    
    
    def isEquivalent(*args, **kwargs):
        """
        Returns True if the distance between the two quaternions (in quaternion space) is less than or equal to the given tolerance.
        """
    
        pass
    
    
    def log(*args, **kwargs):
        """
        Returns a new quaternion containing the natural log of this one.
        """
    
        pass
    
    
    def negateIt(*args, **kwargs):
        """
        In-place negation of the x, y, z and w components.
        """
    
        pass
    
    
    def normal(*args, **kwargs):
        """
        Returns a new quaternion containing the normalized version of this one (i.e. scaled to unit length).
        """
    
        pass
    
    
    def normalizeIt(*args, **kwargs):
        """
        In-place normalization (i.e. scales the quaternion to unit length).
        """
    
        pass
    
    
    def setToXAxis(*args, **kwargs):
        """
        Set this quaternion to be equivalent to a rotation of a given angle, in radians, about the X-axis.
        """
    
        pass
    
    
    def setToYAxis(*args, **kwargs):
        """
        Set this quaternion to be equivalent to a rotation of a given angle, in radians, about the Y-axis.
        """
    
        pass
    
    
    def setToZAxis(*args, **kwargs):
        """
        Set this quaternion to be equivalent to a rotation of a given angle, in radians, about the Z-axis.
        """
    
        pass
    
    
    def setValue(*args, **kwargs):
        """
        Set the value of this quaternion to that of the specified MQuaternion, MEulerRotation, MMatrix or MVector and angle.
        """
    
        pass
    
    
    def slerp(*args, **kwargs):
        """
        Returns the quaternion at a given interpolation value along the shortest path between two quaternions.
        """
    
        pass
    
    
    def squad(*args, **kwargs):
        """
        Returns the quaternion at a given interpolation value along a cubic curve segment in quaternion space.
        """
    
        pass
    
    
    def squadPt(*args, **kwargs):
        """
        Returns a new quaternion representing an intermediate point which when used with squad() will produce a C1 continuous spline.
        """
    
        pass
    
    
    w = None
    
    x = None
    
    y = None
    
    z = None
    
    __new__ = None
    
    
    kIdentity = None
    
    
    kTolerance = None


class MPxCommand(object):
    """
    Base class for custom commands.
    """
    
    
    
    def __init__(*args, **kwargs):
        """
        x.__init__(...) initializes x; see x.__class__.__doc__ for signature
        """
    
        pass
    
    
    def doIt(*args, **kwargs):
        """
        Called by Maya to execute the command.
        """
    
        pass
    
    
    def hasSyntax(*args, **kwargs):
        """
        Called by Maya to determine if the command provides an MSyntax object describing its syntax.
        """
    
        pass
    
    
    def isUndoable(*args, **kwargs):
        """
        Called by Maya to determine if the command supports undo.
        """
    
        pass
    
    
    def redoIt(*args, **kwargs):
        """
        Called by Maya to redo a previously undone command.
        """
    
        pass
    
    
    def syntax(*args, **kwargs):
        """
        Returns the command's MSyntax object, if it has one.
        """
    
        pass
    
    
    def undoIt(*args, **kwargs):
        """
        Called by Maya to undo a previously executed command.
        """
    
        pass
    
    
    def appendToResult(*args, **kwargs):
        """
        Append a value to the result to be returned by the command.
        """
    
        pass
    
    
    def clearResult(*args, **kwargs):
        """
        Clears the command's result.
        """
    
        pass
    
    
    def currentResult(*args, **kwargs):
        """
        Returns the command's current result.
        """
    
        pass
    
    
    def currentResultType(*args, **kwargs):
        """
        Returns the type of the current result.
        """
    
        pass
    
    
    def displayError(*args, **kwargs):
        """
        Display an error message.
        """
    
        pass
    
    
    def displayInfo(*args, **kwargs):
        """
        Display an informational message.
        """
    
        pass
    
    
    def displayWarning(*args, **kwargs):
        """
        Display a warning message.
        """
    
        pass
    
    
    def isCurrentResultArray(*args, **kwargs):
        """
        Returns true if the command's current result is an array of values.
        """
    
        pass
    
    
    def setResult(*args, **kwargs):
        """
        Set the value of the result to be returned by the command.
        """
    
        pass
    
    
    commandString = None
    
    historyOn = None
    
    __new__ = None
    
    
    kDouble = None
    
    
    kLong = None
    
    
    kNoArg = None
    
    
    kString = None


class MDistance(object):
    """
    Manipulate distance data.
    """
    
    
    
    def __init__(*args, **kwargs):
        """
        x.__init__(...) initializes x; see x.__class__.__doc__ for signature
        """
    
        pass
    
    
    def __repr__(*args, **kwargs):
        """
        x.__repr__() <==> repr(x)
        """
    
        pass
    
    
    def __str__(*args, **kwargs):
        """
        x.__str__() <==> str(x)
        """
    
        pass
    
    
    def asCentimeters(*args, **kwargs):
        """
        Return the distance value, converted to centimeters.
        """
    
        pass
    
    
    def asFeet(*args, **kwargs):
        """
        Return the distance value, converted to feet.
        """
    
        pass
    
    
    def asInches(*args, **kwargs):
        """
        Return the distance value, converted to inches.
        """
    
        pass
    
    
    def asKilometers(*args, **kwargs):
        """
        Return the distance value, converted to kilometers.
        """
    
        pass
    
    
    def asMeters(*args, **kwargs):
        """
        Return the distance value, converted to meters.
        """
    
        pass
    
    
    def asMiles(*args, **kwargs):
        """
        Return the distance value, converted to miles.
        """
    
        pass
    
    
    def asMillimeters(*args, **kwargs):
        """
        Return the distance value, converted to millimeters.
        """
    
        pass
    
    
    def asUnits(*args, **kwargs):
        """
        Return the distance value, converted to the specified units.
        """
    
        pass
    
    
    def asYards(*args, **kwargs):
        """
        Return the distance value, converted to yards.
        """
    
        pass
    
    
    def internalToUI(*args, **kwargs):
        """
        Convert a value from Maya's internal units to the units used in the UI.
        """
    
        pass
    
    
    def internalUnit(*args, **kwargs):
        """
        Return the distance unit used internally by Maya.
        """
    
        pass
    
    
    def setUIUnit(*args, **kwargs):
        """
        Change the units used to display distances in Maya's UI.
        """
    
        pass
    
    
    def uiToInternal(*args, **kwargs):
        """
        Convert a value from the units used in the UI to Maya's internal units.
        """
    
        pass
    
    
    def uiUnit(*args, **kwargs):
        """
        Return the units used to display distances in Maya's UI.
        """
    
        pass
    
    
    unit = None
    
    value = None
    
    __new__ = None
    
    
    kCentimeters = None
    
    
    kFeet = None
    
    
    kInches = None
    
    
    kInvalid = None
    
    
    kKilometers = None
    
    
    kLast = None
    
    
    kMeters = None
    
    
    kMiles = None
    
    
    kMillimeters = None
    
    
    kYards = None


class MTime(object):
    """
    Manipulate time data.
    """
    
    
    
    def __add__(*args, **kwargs):
        """
        x.__add__(y) <==> x+y
        """
    
        pass
    
    
    def __div__(*args, **kwargs):
        """
        x.__div__(y) <==> x/y
        """
    
        pass
    
    
    def __eq__(*args, **kwargs):
        """
        x.__eq__(y) <==> x==y
        """
    
        pass
    
    
    def __ge__(*args, **kwargs):
        """
        x.__ge__(y) <==> x>=y
        """
    
        pass
    
    
    def __gt__(*args, **kwargs):
        """
        x.__gt__(y) <==> x>y
        """
    
        pass
    
    
    def __iadd__(*args, **kwargs):
        """
        x.__iadd__(y) <==> x+y
        """
    
        pass
    
    
    def __idiv__(*args, **kwargs):
        """
        x.__idiv__(y) <==> x/y
        """
    
        pass
    
    
    def __imul__(*args, **kwargs):
        """
        x.__imul__(y) <==> x*y
        """
    
        pass
    
    
    def __init__(*args, **kwargs):
        """
        x.__init__(...) initializes x; see x.__class__.__doc__ for signature
        """
    
        pass
    
    
    def __isub__(*args, **kwargs):
        """
        x.__isub__(y) <==> x-y
        """
    
        pass
    
    
    def __le__(*args, **kwargs):
        """
        x.__le__(y) <==> x<=y
        """
    
        pass
    
    
    def __lt__(*args, **kwargs):
        """
        x.__lt__(y) <==> x<y
        """
    
        pass
    
    
    def __mul__(*args, **kwargs):
        """
        x.__mul__(y) <==> x*y
        """
    
        pass
    
    
    def __ne__(*args, **kwargs):
        """
        x.__ne__(y) <==> x!=y
        """
    
        pass
    
    
    def __radd__(*args, **kwargs):
        """
        x.__radd__(y) <==> y+x
        """
    
        pass
    
    
    def __rdiv__(*args, **kwargs):
        """
        x.__rdiv__(y) <==> y/x
        """
    
        pass
    
    
    def __repr__(*args, **kwargs):
        """
        x.__repr__() <==> repr(x)
        """
    
        pass
    
    
    def __rmul__(*args, **kwargs):
        """
        x.__rmul__(y) <==> y*x
        """
    
        pass
    
    
    def __rsub__(*args, **kwargs):
        """
        x.__rsub__(y) <==> y-x
        """
    
        pass
    
    
    def __str__(*args, **kwargs):
        """
        x.__str__() <==> str(x)
        """
    
        pass
    
    
    def __sub__(*args, **kwargs):
        """
        x.__sub__(y) <==> x-y
        """
    
        pass
    
    
    def asUnits(*args, **kwargs):
        """
        Return the time value, converted to the specified units.
        """
    
        pass
    
    
    def setUIUnit(*args, **kwargs):
        """
        Change the units used to display time in Maya's UI.
        """
    
        pass
    
    
    def uiUnit(*args, **kwargs):
        """
        Return the units used to display time in Maya's UI.
        """
    
        pass
    
    
    unit = None
    
    value = None
    
    __new__ = None
    
    
    k100FPS = None
    
    
    k10FPS = None
    
    
    k1200FPS = None
    
    
    k120FPS = None
    
    
    k125FPS = None
    
    
    k12FPS = None
    
    
    k1500FPS = None
    
    
    k150FPS = None
    
    
    k16FPS = None
    
    
    k2000FPS = None
    
    
    k200FPS = None
    
    
    k20FPS = None
    
    
    k240FPS = None
    
    
    k250FPS = None
    
    
    k2FPS = None
    
    
    k3000FPS = None
    
    
    k300FPS = None
    
    
    k375FPS = None
    
    
    k3FPS = None
    
    
    k400FPS = None
    
    
    k40FPS = None
    
    
    k4FPS = None
    
    
    k500FPS = None
    
    
    k5FPS = None
    
    
    k6000FPS = None
    
    
    k600FPS = None
    
    
    k6FPS = None
    
    
    k750FPS = None
    
    
    k75FPS = None
    
    
    k80FPS = None
    
    
    k8FPS = None
    
    
    kFilm = None
    
    
    kGames = None
    
    
    kHours = None
    
    
    kInvalid = None
    
    
    kLast = None
    
    
    kMilliseconds = None
    
    
    kMinutes = None
    
    
    kNTSCField = None
    
    
    kNTSCFrame = None
    
    
    kPALField = None
    
    
    kPALFrame = None
    
    
    kSeconds = None
    
    
    kShowScan = None
    
    
    kUserDef = None


class MColorArray(object):
    """
    Array of MColor values.
    """
    
    
    
    def __add__(*args, **kwargs):
        """
        x.__add__(y) <==> x+y
        """
    
        pass
    
    
    def __contains__(*args, **kwargs):
        """
        x.__contains__(y) <==> y in x
        """
    
        pass
    
    
    def __delitem__(*args, **kwargs):
        """
        x.__delitem__(y) <==> del x[y]
        """
    
        pass
    
    
    def __getitem__(*args, **kwargs):
        """
        x.__getitem__(y) <==> x[y]
        """
    
        pass
    
    
    def __iadd__(*args, **kwargs):
        """
        x.__iadd__(y) <==> x+=y
        """
    
        pass
    
    
    def __imul__(*args, **kwargs):
        """
        x.__imul__(y) <==> x*=y
        """
    
        pass
    
    
    def __init__(*args, **kwargs):
        """
        x.__init__(...) initializes x; see x.__class__.__doc__ for signature
        """
    
        pass
    
    
    def __len__(*args, **kwargs):
        """
        x.__len__() <==> len(x)
        """
    
        pass
    
    
    def __mul__(*args, **kwargs):
        """
        x.__mul__(n) <==> x*n
        """
    
        pass
    
    
    def __repr__(*args, **kwargs):
        """
        x.__repr__() <==> repr(x)
        """
    
        pass
    
    
    def __rmul__(*args, **kwargs):
        """
        x.__rmul__(n) <==> n*x
        """
    
        pass
    
    
    def __setitem__(*args, **kwargs):
        """
        x.__setitem__(i, y) <==> x[i]=y
        """
    
        pass
    
    
    def __str__(*args, **kwargs):
        """
        x.__str__() <==> str(x)
        """
    
        pass
    
    
    def append(*args, **kwargs):
        """
        Add a value to the end of the array.
        """
    
        pass
    
    
    def clear(*args, **kwargs):
        """
        Remove all elements from the array.
        """
    
        pass
    
    
    def copy(*args, **kwargs):
        """
        Replace the array contents with that of another or of a compatible Python sequence.
        """
    
        pass
    
    
    def insert(*args, **kwargs):
        """
        Insert a new value into the array at the given index.
        """
    
        pass
    
    
    def remove(*args, **kwargs):
        """
        Remove an element from the array.
        """
    
        pass
    
    
    def setLength(*args, **kwargs):
        """
        Grow or shrink the array to contain a specific number of elements.
        """
    
        pass
    
    
    sizeIncrement = None
    
    __new__ = None


class MMatrix(object):
    """
    4x4 matrix with double-precision elements.
    """
    
    
    
    def __add__(*args, **kwargs):
        """
        x.__add__(y) <==> x+y
        """
    
        pass
    
    
    def __delitem__(*args, **kwargs):
        """
        x.__delitem__(y) <==> del x[y]
        """
    
        pass
    
    
    def __eq__(*args, **kwargs):
        """
        x.__eq__(y) <==> x==y
        """
    
        pass
    
    
    def __ge__(*args, **kwargs):
        """
        x.__ge__(y) <==> x>=y
        """
    
        pass
    
    
    def __getitem__(*args, **kwargs):
        """
        x.__getitem__(y) <==> x[y]
        """
    
        pass
    
    
    def __gt__(*args, **kwargs):
        """
        x.__gt__(y) <==> x>y
        """
    
        pass
    
    
    def __iadd__(*args, **kwargs):
        """
        x.__iadd__(y) <==> x+y
        """
    
        pass
    
    
    def __imul__(*args, **kwargs):
        """
        x.__imul__(y) <==> x*y
        """
    
        pass
    
    
    def __init__(*args, **kwargs):
        """
        x.__init__(...) initializes x; see x.__class__.__doc__ for signature
        """
    
        pass
    
    
    def __isub__(*args, **kwargs):
        """
        x.__isub__(y) <==> x-y
        """
    
        pass
    
    
    def __le__(*args, **kwargs):
        """
        x.__le__(y) <==> x<=y
        """
    
        pass
    
    
    def __len__(*args, **kwargs):
        """
        x.__len__() <==> len(x)
        """
    
        pass
    
    
    def __lt__(*args, **kwargs):
        """
        x.__lt__(y) <==> x<y
        """
    
        pass
    
    
    def __mul__(*args, **kwargs):
        """
        x.__mul__(y) <==> x*y
        """
    
        pass
    
    
    def __ne__(*args, **kwargs):
        """
        x.__ne__(y) <==> x!=y
        """
    
        pass
    
    
    def __radd__(*args, **kwargs):
        """
        x.__radd__(y) <==> y+x
        """
    
        pass
    
    
    def __repr__(*args, **kwargs):
        """
        x.__repr__() <==> repr(x)
        """
    
        pass
    
    
    def __rmul__(*args, **kwargs):
        """
        x.__rmul__(y) <==> y*x
        """
    
        pass
    
    
    def __rsub__(*args, **kwargs):
        """
        x.__rsub__(y) <==> y-x
        """
    
        pass
    
    
    def __setitem__(*args, **kwargs):
        """
        x.__setitem__(i, y) <==> x[i]=y
        """
    
        pass
    
    
    def __str__(*args, **kwargs):
        """
        x.__str__() <==> str(x)
        """
    
        pass
    
    
    def __sub__(*args, **kwargs):
        """
        x.__sub__(y) <==> x-y
        """
    
        pass
    
    
    def adjoint(*args, **kwargs):
        """
        Returns a new matrix containing this matrix's adjoint.
        """
    
        pass
    
    
    def det3x3(*args, **kwargs):
        """
        Returns the determinant of the 3x3 matrix formed by the first 3 elements of the first 3 rows of this matrix.
        """
    
        pass
    
    
    def det4x4(*args, **kwargs):
        """
        Returns this matrix's determinant.
        """
    
        pass
    
    
    def getElement(*args, **kwargs):
        """
        Returns the matrix element for the specified row and column.
        """
    
        pass
    
    
    def homogenize(*args, **kwargs):
        """
        Returns a new matrix containing the homogenized version of this matrix.
        """
    
        pass
    
    
    def inverse(*args, **kwargs):
        """
        Returns a new matrix containing this matrix's inverse.
        """
    
        pass
    
    
    def isEquivalent(*args, **kwargs):
        """
        Test for equivalence of two matrices, within a tolerance.
        """
    
        pass
    
    
    def isSingular(*args, **kwargs):
        """
        Returns True if this matrix is singular.
        """
    
        pass
    
    
    def setElement(*args, **kwargs):
        """
        Sets the matrix element for the specified row and column.
        """
    
        pass
    
    
    def setToIdentity(*args, **kwargs):
        """
        Sets this matrix to the identity.
        """
    
        pass
    
    
    def setToProduct(*args, **kwargs):
        """
        Sets this matrix to the product of the two matrices passed in.
        """
    
        pass
    
    
    def transpose(*args, **kwargs):
        """
        Returns a new matrix containing this matrix's transpose.
        """
    
        pass
    
    
    __new__ = None
    
    
    kIdentity = None
    
    
    kTolerance = None


class MDoubleArray(object):
    """
    Array of double values.
    """
    
    
    
    def __add__(*args, **kwargs):
        """
        x.__add__(y) <==> x+y
        """
    
        pass
    
    
    def __contains__(*args, **kwargs):
        """
        x.__contains__(y) <==> y in x
        """
    
        pass
    
    
    def __delitem__(*args, **kwargs):
        """
        x.__delitem__(y) <==> del x[y]
        """
    
        pass
    
    
    def __getitem__(*args, **kwargs):
        """
        x.__getitem__(y) <==> x[y]
        """
    
        pass
    
    
    def __iadd__(*args, **kwargs):
        """
        x.__iadd__(y) <==> x+=y
        """
    
        pass
    
    
    def __imul__(*args, **kwargs):
        """
        x.__imul__(y) <==> x*=y
        """
    
        pass
    
    
    def __init__(*args, **kwargs):
        """
        x.__init__(...) initializes x; see x.__class__.__doc__ for signature
        """
    
        pass
    
    
    def __len__(*args, **kwargs):
        """
        x.__len__() <==> len(x)
        """
    
        pass
    
    
    def __mul__(*args, **kwargs):
        """
        x.__mul__(n) <==> x*n
        """
    
        pass
    
    
    def __repr__(*args, **kwargs):
        """
        x.__repr__() <==> repr(x)
        """
    
        pass
    
    
    def __rmul__(*args, **kwargs):
        """
        x.__rmul__(n) <==> n*x
        """
    
        pass
    
    
    def __setitem__(*args, **kwargs):
        """
        x.__setitem__(i, y) <==> x[i]=y
        """
    
        pass
    
    
    def __str__(*args, **kwargs):
        """
        x.__str__() <==> str(x)
        """
    
        pass
    
    
    def append(*args, **kwargs):
        """
        Add a value to the end of the array.
        """
    
        pass
    
    
    def clear(*args, **kwargs):
        """
        Remove all elements from the array.
        """
    
        pass
    
    
    def copy(*args, **kwargs):
        """
        Replace the array contents with that of another or of a compatible Python sequence.
        """
    
        pass
    
    
    def insert(*args, **kwargs):
        """
        Insert a new value into the array at the given index.
        """
    
        pass
    
    
    def remove(*args, **kwargs):
        """
        Remove an element from the array.
        """
    
        pass
    
    
    def setLength(*args, **kwargs):
        """
        Grow or shrink the array to contain a specific number of elements.
        """
    
        pass
    
    
    sizeIncrement = None
    
    __new__ = None


class MSyntax(object):
    """
    Syntax for commands.
    """
    
    
    
    def __init__(*args, **kwargs):
        """
        x.__init__(...) initializes x; see x.__class__.__doc__ for signature
        """
    
        pass
    
    
    def addArg(*args, **kwargs):
        """
        Add a command argument.
        """
    
        pass
    
    
    def addFlag(*args, **kwargs):
        """
        Add a flag and its arguments.
        """
    
        pass
    
    
    def makeFlagMultiUse(*args, **kwargs):
        """
        Set whether a flag may be used multiple times on the command line.
        """
    
        pass
    
    
    def makeFlagQueryWithFullArgs(*args, **kwargs):
        """
        Set whether a flag requires its args when queried.
        """
    
        pass
    
    
    def setObjectType(*args, **kwargs):
        """
        Set the type and number of objects to be passed to the command.
        """
    
        pass
    
    
    def useSelectionAsDefault(*args, **kwargs):
        """
        Use the current selection if no objects were provided on the command-line.
        """
    
        pass
    
    
    enableEdit = None
    
    enableQuery = None
    
    maxObjects = None
    
    minObjects = None
    
    __new__ = None
    
    
    kAngle = None
    
    
    kBoolean = None
    
    
    kDistance = None
    
    
    kDouble = None
    
    
    kInvalidArgType = None
    
    
    kInvalidObjectFormat = None
    
    
    kLastArgType = None
    
    
    kLastObjectFormat = None
    
    
    kLong = None
    
    
    kNoArg = None
    
    
    kNone = None
    
    
    kSelectionItem = None
    
    
    kSelectionList = None
    
    
    kString = None
    
    
    kStringObjects = None
    
    
    kTime = None
    
    
    kUnsigned = None


class MIntArray(object):
    """
    Array of int values.
    """
    
    
    
    def __add__(*args, **kwargs):
        """
        x.__add__(y) <==> x+y
        """
    
        pass
    
    
    def __contains__(*args, **kwargs):
        """
        x.__contains__(y) <==> y in x
        """
    
        pass
    
    
    def __delitem__(*args, **kwargs):
        """
        x.__delitem__(y) <==> del x[y]
        """
    
        pass
    
    
    def __getitem__(*args, **kwargs):
        """
        x.__getitem__(y) <==> x[y]
        """
    
        pass
    
    
    def __iadd__(*args, **kwargs):
        """
        x.__iadd__(y) <==> x+=y
        """
    
        pass
    
    
    def __imul__(*args, **kwargs):
        """
        x.__imul__(y) <==> x*=y
        """
    
        pass
    
    
    def __init__(*args, **kwargs):
        """
        x.__init__(...) initializes x; see x.__class__.__doc__ for signature
        """
    
        pass
    
    
    def __len__(*args, **kwargs):
        """
        x.__len__() <==> len(x)
        """
    
        pass
    
    
    def __mul__(*args, **kwargs):
        """
        x.__mul__(n) <==> x*n
        """
    
        pass
    
    
    def __repr__(*args, **kwargs):
        """
        x.__repr__() <==> repr(x)
        """
    
        pass
    
    
    def __rmul__(*args, **kwargs):
        """
        x.__rmul__(n) <==> n*x
        """
    
        pass
    
    
    def __setitem__(*args, **kwargs):
        """
        x.__setitem__(i, y) <==> x[i]=y
        """
    
        pass
    
    
    def __str__(*args, **kwargs):
        """
        x.__str__() <==> str(x)
        """
    
        pass
    
    
    def append(*args, **kwargs):
        """
        Add a value to the end of the array.
        """
    
        pass
    
    
    def clear(*args, **kwargs):
        """
        Remove all elements from the array.
        """
    
        pass
    
    
    def copy(*args, **kwargs):
        """
        Replace the array contents with that of another or of a compatible Python sequence.
        """
    
        pass
    
    
    def insert(*args, **kwargs):
        """
        Insert a new value into the array at the given index.
        """
    
        pass
    
    
    def remove(*args, **kwargs):
        """
        Remove an element from the array.
        """
    
        pass
    
    
    def setLength(*args, **kwargs):
        """
        Grow or shrink the array to contain a specific number of elements.
        """
    
        pass
    
    
    sizeIncrement = None
    
    __new__ = None


class MPlugArray(object):
    """
    Array of MPlug values.
    """
    
    
    
    def __add__(*args, **kwargs):
        """
        x.__add__(y) <==> x+y
        """
    
        pass
    
    
    def __contains__(*args, **kwargs):
        """
        x.__contains__(y) <==> y in x
        """
    
        pass
    
    
    def __delitem__(*args, **kwargs):
        """
        x.__delitem__(y) <==> del x[y]
        """
    
        pass
    
    
    def __getitem__(*args, **kwargs):
        """
        x.__getitem__(y) <==> x[y]
        """
    
        pass
    
    
    def __iadd__(*args, **kwargs):
        """
        x.__iadd__(y) <==> x+=y
        """
    
        pass
    
    
    def __imul__(*args, **kwargs):
        """
        x.__imul__(y) <==> x*=y
        """
    
        pass
    
    
    def __init__(*args, **kwargs):
        """
        x.__init__(...) initializes x; see x.__class__.__doc__ for signature
        """
    
        pass
    
    
    def __len__(*args, **kwargs):
        """
        x.__len__() <==> len(x)
        """
    
        pass
    
    
    def __mul__(*args, **kwargs):
        """
        x.__mul__(n) <==> x*n
        """
    
        pass
    
    
    def __repr__(*args, **kwargs):
        """
        x.__repr__() <==> repr(x)
        """
    
        pass
    
    
    def __rmul__(*args, **kwargs):
        """
        x.__rmul__(n) <==> n*x
        """
    
        pass
    
    
    def __setitem__(*args, **kwargs):
        """
        x.__setitem__(i, y) <==> x[i]=y
        """
    
        pass
    
    
    def __str__(*args, **kwargs):
        """
        x.__str__() <==> str(x)
        """
    
        pass
    
    
    def append(*args, **kwargs):
        """
        Add a value to the end of the array.
        """
    
        pass
    
    
    def clear(*args, **kwargs):
        """
        Remove all elements from the array.
        """
    
        pass
    
    
    def copy(*args, **kwargs):
        """
        Replace the array contents with that of another or of a compatible Python sequence.
        """
    
        pass
    
    
    def insert(*args, **kwargs):
        """
        Insert a new value into the array at the given index.
        """
    
        pass
    
    
    def remove(*args, **kwargs):
        """
        Remove an element from the array.
        """
    
        pass
    
    
    def setLength(*args, **kwargs):
        """
        Grow or shrink the array to contain a specific number of elements.
        """
    
        pass
    
    
    sizeIncrement = None
    
    __new__ = None


class MColor(object):
    """
    Manipulate color data.
    """
    
    
    
    def __add__(*args, **kwargs):
        """
        x.__add__(y) <==> x+y
        """
    
        pass
    
    
    def __delitem__(*args, **kwargs):
        """
        x.__delitem__(y) <==> del x[y]
        """
    
        pass
    
    
    def __div__(*args, **kwargs):
        """
        x.__div__(y) <==> x/y
        """
    
        pass
    
    
    def __eq__(*args, **kwargs):
        """
        x.__eq__(y) <==> x==y
        """
    
        pass
    
    
    def __ge__(*args, **kwargs):
        """
        x.__ge__(y) <==> x>=y
        """
    
        pass
    
    
    def __getitem__(*args, **kwargs):
        """
        x.__getitem__(y) <==> x[y]
        """
    
        pass
    
    
    def __gt__(*args, **kwargs):
        """
        x.__gt__(y) <==> x>y
        """
    
        pass
    
    
    def __iadd__(*args, **kwargs):
        """
        x.__iadd__(y) <==> x+y
        """
    
        pass
    
    
    def __idiv__(*args, **kwargs):
        """
        x.__idiv__(y) <==> x/y
        """
    
        pass
    
    
    def __imul__(*args, **kwargs):
        """
        x.__imul__(y) <==> x*y
        """
    
        pass
    
    
    def __init__(*args, **kwargs):
        """
        x.__init__(...) initializes x; see x.__class__.__doc__ for signature
        """
    
        pass
    
    
    def __le__(*args, **kwargs):
        """
        x.__le__(y) <==> x<=y
        """
    
        pass
    
    
    def __len__(*args, **kwargs):
        """
        x.__len__() <==> len(x)
        """
    
        pass
    
    
    def __lt__(*args, **kwargs):
        """
        x.__lt__(y) <==> x<y
        """
    
        pass
    
    
    def __mul__(*args, **kwargs):
        """
        x.__mul__(y) <==> x*y
        """
    
        pass
    
    
    def __ne__(*args, **kwargs):
        """
        x.__ne__(y) <==> x!=y
        """
    
        pass
    
    
    def __radd__(*args, **kwargs):
        """
        x.__radd__(y) <==> y+x
        """
    
        pass
    
    
    def __rdiv__(*args, **kwargs):
        """
        x.__rdiv__(y) <==> y/x
        """
    
        pass
    
    
    def __repr__(*args, **kwargs):
        """
        x.__repr__() <==> repr(x)
        """
    
        pass
    
    
    def __rmul__(*args, **kwargs):
        """
        x.__rmul__(y) <==> y*x
        """
    
        pass
    
    
    def __setitem__(*args, **kwargs):
        """
        x.__setitem__(i, y) <==> x[i]=y
        """
    
        pass
    
    
    def __str__(*args, **kwargs):
        """
        x.__str__() <==> str(x)
        """
    
        pass
    
    
    def getColor(*args, **kwargs):
        """
        Returns a list containing the color's components, in the specified color model.
        """
    
        pass
    
    
    def setColor(*args, **kwargs):
        """
        Sets the color's components and color model.
        """
    
        pass
    
    
    a = None
    
    b = None
    
    g = None
    
    r = None
    
    __new__ = None
    
    
    kByte = None
    
    
    kCMY = None
    
    
    kCMYK = None
    
    
    kFloat = None
    
    
    kHSV = None
    
    
    kOpaqueBlack = None
    
    
    kRGB = None
    
    
    kShort = None


class MFloatArray(object):
    """
    Array of float values.
    """
    
    
    
    def __add__(*args, **kwargs):
        """
        x.__add__(y) <==> x+y
        """
    
        pass
    
    
    def __contains__(*args, **kwargs):
        """
        x.__contains__(y) <==> y in x
        """
    
        pass
    
    
    def __delitem__(*args, **kwargs):
        """
        x.__delitem__(y) <==> del x[y]
        """
    
        pass
    
    
    def __getitem__(*args, **kwargs):
        """
        x.__getitem__(y) <==> x[y]
        """
    
        pass
    
    
    def __iadd__(*args, **kwargs):
        """
        x.__iadd__(y) <==> x+=y
        """
    
        pass
    
    
    def __imul__(*args, **kwargs):
        """
        x.__imul__(y) <==> x*=y
        """
    
        pass
    
    
    def __init__(*args, **kwargs):
        """
        x.__init__(...) initializes x; see x.__class__.__doc__ for signature
        """
    
        pass
    
    
    def __len__(*args, **kwargs):
        """
        x.__len__() <==> len(x)
        """
    
        pass
    
    
    def __mul__(*args, **kwargs):
        """
        x.__mul__(n) <==> x*n
        """
    
        pass
    
    
    def __repr__(*args, **kwargs):
        """
        x.__repr__() <==> repr(x)
        """
    
        pass
    
    
    def __rmul__(*args, **kwargs):
        """
        x.__rmul__(n) <==> n*x
        """
    
        pass
    
    
    def __setitem__(*args, **kwargs):
        """
        x.__setitem__(i, y) <==> x[i]=y
        """
    
        pass
    
    
    def __str__(*args, **kwargs):
        """
        x.__str__() <==> str(x)
        """
    
        pass
    
    
    def append(*args, **kwargs):
        """
        Add a value to the end of the array.
        """
    
        pass
    
    
    def clear(*args, **kwargs):
        """
        Remove all elements from the array.
        """
    
        pass
    
    
    def copy(*args, **kwargs):
        """
        Replace the array contents with that of another or of a compatible Python sequence.
        """
    
        pass
    
    
    def insert(*args, **kwargs):
        """
        Insert a new value into the array at the given index.
        """
    
        pass
    
    
    def remove(*args, **kwargs):
        """
        Remove an element from the array.
        """
    
        pass
    
    
    def setLength(*args, **kwargs):
        """
        Grow or shrink the array to contain a specific number of elements.
        """
    
        pass
    
    
    sizeIncrement = None
    
    __new__ = None


class MGlobal(object):
    """
    Static class providing common API global functions.
    """
    
    
    
    def getActiveSelectionList(*args, **kwargs):
        """
        Return an MSelectionList containing the nodes, components and plugs currently selected in Maya.
        """
    
        pass
    
    
    kAddToHeadOfList = None
    
    
    kAddToList = None
    
    
    kBaseUIMode = None
    
    
    kBatch = None
    
    
    kInteractive = None
    
    
    kLibraryApp = None
    
    
    kRemoveFromList = None
    
    
    kReplaceList = None
    
    
    kSelectComponentMode = None
    
    
    kSelectLeafMode = None
    
    
    kSelectObjectMode = None
    
    
    kSelectRootMode = None
    
    
    kSelectTemplateMode = None
    
    
    kSurfaceSelectMethod = None
    
    
    kWireframeSelectMethod = None
    
    
    kXORWithList = None


class MFloatMatrix(object):
    """
    4x4 matrix with single-precision elements.
    """
    
    
    
    def __add__(*args, **kwargs):
        """
        x.__add__(y) <==> x+y
        """
    
        pass
    
    
    def __delitem__(*args, **kwargs):
        """
        x.__delitem__(y) <==> del x[y]
        """
    
        pass
    
    
    def __eq__(*args, **kwargs):
        """
        x.__eq__(y) <==> x==y
        """
    
        pass
    
    
    def __ge__(*args, **kwargs):
        """
        x.__ge__(y) <==> x>=y
        """
    
        pass
    
    
    def __getitem__(*args, **kwargs):
        """
        x.__getitem__(y) <==> x[y]
        """
    
        pass
    
    
    def __gt__(*args, **kwargs):
        """
        x.__gt__(y) <==> x>y
        """
    
        pass
    
    
    def __iadd__(*args, **kwargs):
        """
        x.__iadd__(y) <==> x+y
        """
    
        pass
    
    
    def __imul__(*args, **kwargs):
        """
        x.__imul__(y) <==> x*y
        """
    
        pass
    
    
    def __init__(*args, **kwargs):
        """
        x.__init__(...) initializes x; see x.__class__.__doc__ for signature
        """
    
        pass
    
    
    def __isub__(*args, **kwargs):
        """
        x.__isub__(y) <==> x-y
        """
    
        pass
    
    
    def __le__(*args, **kwargs):
        """
        x.__le__(y) <==> x<=y
        """
    
        pass
    
    
    def __len__(*args, **kwargs):
        """
        x.__len__() <==> len(x)
        """
    
        pass
    
    
    def __lt__(*args, **kwargs):
        """
        x.__lt__(y) <==> x<y
        """
    
        pass
    
    
    def __mul__(*args, **kwargs):
        """
        x.__mul__(y) <==> x*y
        """
    
        pass
    
    
    def __ne__(*args, **kwargs):
        """
        x.__ne__(y) <==> x!=y
        """
    
        pass
    
    
    def __radd__(*args, **kwargs):
        """
        x.__radd__(y) <==> y+x
        """
    
        pass
    
    
    def __repr__(*args, **kwargs):
        """
        x.__repr__() <==> repr(x)
        """
    
        pass
    
    
    def __rmul__(*args, **kwargs):
        """
        x.__rmul__(y) <==> y*x
        """
    
        pass
    
    
    def __rsub__(*args, **kwargs):
        """
        x.__rsub__(y) <==> y-x
        """
    
        pass
    
    
    def __setitem__(*args, **kwargs):
        """
        x.__setitem__(i, y) <==> x[i]=y
        """
    
        pass
    
    
    def __str__(*args, **kwargs):
        """
        x.__str__() <==> str(x)
        """
    
        pass
    
    
    def __sub__(*args, **kwargs):
        """
        x.__sub__(y) <==> x-y
        """
    
        pass
    
    
    def adjoint(*args, **kwargs):
        """
        Returns a new matrix containing this matrix's adjoint.
        """
    
        pass
    
    
    def det3x3(*args, **kwargs):
        """
        Returns the determinant of the 3x3 matrix formed by the first 3 elements of the first 3 rows of this matrix.
        """
    
        pass
    
    
    def det4x4(*args, **kwargs):
        """
        Returns this matrix's determinant.
        """
    
        pass
    
    
    def getElement(*args, **kwargs):
        """
        Returns the matrix element for the specified row and column.
        """
    
        pass
    
    
    def homogenize(*args, **kwargs):
        """
        Returns a new matrix containing the homogenized version of this matrix.
        """
    
        pass
    
    
    def inverse(*args, **kwargs):
        """
        Returns a new matrix containing this matrix's inverse.
        """
    
        pass
    
    
    def isEquivalent(*args, **kwargs):
        """
        Test for equivalence of two matrices, within a tolerance.
        """
    
        pass
    
    
    def setElement(*args, **kwargs):
        """
        Sets the matrix element for the specified row and column.
        """
    
        pass
    
    
    def setToIdentity(*args, **kwargs):
        """
        Sets this matrix to the identity.
        """
    
        pass
    
    
    def setToProduct(*args, **kwargs):
        """
        Sets this matrix to the product of the two matrices passed in.
        """
    
        pass
    
    
    def transpose(*args, **kwargs):
        """
        Returns a new matrix containing this matrix's transpose.
        """
    
        pass
    
    
    __new__ = None
    
    
    kTolerance = None


class MEulerRotation(object):
    """
    X, Y and Z rotations, applied in a specified order.
    """
    
    
    
    def __add__(*args, **kwargs):
        """
        x.__add__(y) <==> x+y
        """
    
        pass
    
    
    def __delitem__(*args, **kwargs):
        """
        x.__delitem__(y) <==> del x[y]
        """
    
        pass
    
    
    def __eq__(*args, **kwargs):
        """
        x.__eq__(y) <==> x==y
        """
    
        pass
    
    
    def __ge__(*args, **kwargs):
        """
        x.__ge__(y) <==> x>=y
        """
    
        pass
    
    
    def __getitem__(*args, **kwargs):
        """
        x.__getitem__(y) <==> x[y]
        """
    
        pass
    
    
    def __gt__(*args, **kwargs):
        """
        x.__gt__(y) <==> x>y
        """
    
        pass
    
    
    def __iadd__(*args, **kwargs):
        """
        x.__iadd__(y) <==> x+y
        """
    
        pass
    
    
    def __imul__(*args, **kwargs):
        """
        x.__imul__(y) <==> x*y
        """
    
        pass
    
    
    def __init__(*args, **kwargs):
        """
        x.__init__(...) initializes x; see x.__class__.__doc__ for signature
        """
    
        pass
    
    
    def __isub__(*args, **kwargs):
        """
        x.__isub__(y) <==> x-y
        """
    
        pass
    
    
    def __le__(*args, **kwargs):
        """
        x.__le__(y) <==> x<=y
        """
    
        pass
    
    
    def __len__(*args, **kwargs):
        """
        x.__len__() <==> len(x)
        """
    
        pass
    
    
    def __lt__(*args, **kwargs):
        """
        x.__lt__(y) <==> x<y
        """
    
        pass
    
    
    def __mul__(*args, **kwargs):
        """
        x.__mul__(y) <==> x*y
        """
    
        pass
    
    
    def __ne__(*args, **kwargs):
        """
        x.__ne__(y) <==> x!=y
        """
    
        pass
    
    
    def __neg__(*args, **kwargs):
        """
        x.__neg__() <==> -x
        """
    
        pass
    
    
    def __radd__(*args, **kwargs):
        """
        x.__radd__(y) <==> y+x
        """
    
        pass
    
    
    def __repr__(*args, **kwargs):
        """
        x.__repr__() <==> repr(x)
        """
    
        pass
    
    
    def __rmul__(*args, **kwargs):
        """
        x.__rmul__(y) <==> y*x
        """
    
        pass
    
    
    def __rsub__(*args, **kwargs):
        """
        x.__rsub__(y) <==> y-x
        """
    
        pass
    
    
    def __setitem__(*args, **kwargs):
        """
        x.__setitem__(i, y) <==> x[i]=y
        """
    
        pass
    
    
    def __str__(*args, **kwargs):
        """
        x.__str__() <==> str(x)
        """
    
        pass
    
    
    def __sub__(*args, **kwargs):
        """
        x.__sub__(y) <==> x-y
        """
    
        pass
    
    
    def alternateSolution(*args, **kwargs):
        """
        Returns an equivalent rotation which is not simply a multiple.
        """
    
        pass
    
    
    def asMatrix(*args, **kwargs):
        """
        Returns the rotation as an equivalent matrix.
        """
    
        pass
    
    
    def asQuaternion(*args, **kwargs):
        """
        Returns the rotation as an equivalent quaternion.
        """
    
        pass
    
    
    def asVector(*args, **kwargs):
        """
        Returns the X, Y and Z rotations as a vector.
        """
    
        pass
    
    
    def bound(*args, **kwargs):
        """
        Returns a new MEulerRotation having this rotation, but with each rotation component bound within +/- PI.
        """
    
        pass
    
    
    def boundIt(*args, **kwargs):
        """
        In-place bounding of each rotation component to lie wthin +/- PI.
        """
    
        pass
    
    
    def closestCut(*args, **kwargs):
        """
        Returns the rotation which is full spin multiples of this one and comes closest to target.
        """
    
        pass
    
    
    def closestSolution(*args, **kwargs):
        """
        Returns the equivalent rotation which comes closest to a target.
        """
    
        pass
    
    
    def incrementalRotateBy(*args, **kwargs):
        """
        Increase this rotation by a given angle around the specified axis. The update is done in series of small increments to avoid flipping.
        """
    
        pass
    
    
    def inverse(*args, **kwargs):
        """
        Returns a new MEulerRotation containing the inverse rotation of this one and reversed rotation order.
        """
    
        pass
    
    
    def invertIt(*args, **kwargs):
        """
        In-place inversion of the rotation. Rotation order is also reversed.
        """
    
        pass
    
    
    def isEquivalent(*args, **kwargs):
        """
        Returns true if this rotation has the same order as another and their X, Y and Z components are within a tolerance of each other.
        """
    
        pass
    
    
    def isZero(*args, **kwargs):
        """
        Returns true if the X, Y and Z components are each within a tolerance of 0.0.
        """
    
        pass
    
    
    def reorder(*args, **kwargs):
        """
        Returns a new MEulerRotation having this rotation, reordered to use the given rotation order.
        """
    
        pass
    
    
    def reorderIt(*args, **kwargs):
        """
        In-place reordering to use the given rotation order.
        """
    
        pass
    
    
    def setToAlternateSolution(*args, **kwargs):
        """
        Replace this rotation with an alternate solution.
        """
    
        pass
    
    
    def setToClosestCut(*args, **kwargs):
        """
        Replace this rotation with the closest cut to a target.
        """
    
        pass
    
    
    def setToClosestSolution(*args, **kwargs):
        """
        Replace this rotation with the closest solution to a target.
        """
    
        pass
    
    
    def setValue(*args, **kwargs):
        """
        Set the rotation.
        """
    
        pass
    
    
    def computeAlternateSolution(*args, **kwargs):
        """
        Returns an equivalent rotation which is not simply a multiple.
        """
    
        pass
    
    
    def computeBound(*args, **kwargs):
        """
        Returns an equivalent rotation with each rotation component bound within +/- PI.
        """
    
        pass
    
    
    def computeClosestCut(*args, **kwargs):
        """
        Returns the rotation which is full spin multiples of the src and comes closest to target.
        """
    
        pass
    
    
    def computeClosestSolution(*args, **kwargs):
        """
        Returns the equivalent rotation which comes closest to a target.
        """
    
        pass
    
    
    def decompose(*args, **kwargs):
        """
        Extracts a rotation from a matrix.
        """
    
        pass
    
    
    order = None
    
    x = None
    
    y = None
    
    z = None
    
    __new__ = None
    
    
    kIdentity = None
    
    
    kTolerance = None
    
    
    kXYZ = None
    
    
    kXZY = None
    
    
    kYXZ = None
    
    
    kYZX = None
    
    
    kZXY = None
    
    
    kZYX = None


class MBoundingBox(object):
    """
    3D axis-aligned bounding box.
    """
    
    
    
    def __init__(*args, **kwargs):
        """
        x.__init__(...) initializes x; see x.__class__.__doc__ for signature
        """
    
        pass
    
    
    def __repr__(*args, **kwargs):
        """
        x.__repr__() <==> repr(x)
        """
    
        pass
    
    
    def __str__(*args, **kwargs):
        """
        x.__str__() <==> str(x)
        """
    
        pass
    
    
    def clear(*args, **kwargs):
        """
        Empties the bounding box, setting its corners to (0, 0, 0).
        """
    
        pass
    
    
    def contains(*args, **kwargs):
        """
        Returns True if a point lies within the bounding box.
        """
    
        pass
    
    
    def expand(*args, **kwargs):
        """
        Expands the bounding box to include a point or other bounding box.
        """
    
        pass
    
    
    def intersects(*args, **kwargs):
        """
        Returns True if any part of a given bounding box lies within this one.
        """
    
        pass
    
    
    def transformUsing(*args, **kwargs):
        """
        Multiplies the bounding box's corners by a matrix.
        """
    
        pass
    
    
    center = None
    
    depth = None
    
    height = None
    
    max = None
    
    min = None
    
    width = None
    
    __new__ = None


class MFn(object):
    """
    Static class providing constants for all API types.
    """
    
    
    
    kAISEnvFacade = None
    
    
    kAddDoubleLinear = None
    
    
    kAdskMaterial = None
    
    
    kAffect = None
    
    
    kAimConstraint = None
    
    
    kAir = None
    
    
    kAlignCurve = None
    
    
    kAlignManip = None
    
    
    kAlignSurface = None
    
    
    kAmbientLight = None
    
    
    kAngle = None
    
    
    kAngleBetween = None
    
    
    kAnimBlend = None
    
    
    kAnimBlendInOut = None
    
    
    kAnimCurve = None
    
    
    kAnimCurveTimeToAngular = None
    
    
    kAnimCurveTimeToDistance = None
    
    
    kAnimCurveTimeToTime = None
    
    
    kAnimCurveTimeToUnitless = None
    
    
    kAnimCurveUnitlessToAngular = None
    
    
    kAnimCurveUnitlessToDistance = None
    
    
    kAnimCurveUnitlessToTime = None
    
    
    kAnimCurveUnitlessToUnitless = None
    
    
    kAnimLayer = None
    
    
    kAnisotropy = None
    
    
    kAnnotation = None
    
    
    kAnyGeometryVarGroup = None
    
    
    kArcLength = None
    
    
    kAreaLight = None
    
    
    kArrayMapper = None
    
    
    kArrowManip = None
    
    
    kAsset = None
    
    
    kAttachCurve = None
    
    
    kAttachSurface = None
    
    
    kAttribute = None
    
    
    kAttribute2Double = None
    
    
    kAttribute2Float = None
    
    
    kAttribute2Int = None
    
    
    kAttribute2Long = None
    
    
    kAttribute2Short = None
    
    
    kAttribute3Double = None
    
    
    kAttribute3Float = None
    
    
    kAttribute3Int = None
    
    
    kAttribute3Long = None
    
    
    kAttribute3Short = None
    
    
    kAttribute4Double = None
    
    
    kAudio = None
    
    
    kAverageCurveManip = None
    
    
    kAvgCurves = None
    
    
    kAvgNurbsSurfacePoints = None
    
    
    kAvgSurfacePoints = None
    
    
    kAxesActionManip = None
    
    
    kBackground = None
    
    
    kBallProjectionManip = None
    
    
    kBarnDoorManip = None
    
    
    kBase = None
    
    
    kBaseLattice = None
    
    
    kBendLattice = None
    
    
    kBevel = None
    
    
    kBevelManip = None
    
    
    kBevelPlus = None
    
    
    kBezierCurve = None
    
    
    kBezierCurveData = None
    
    
    kBezierCurveToNurbs = None
    
    
    kBinaryData = None
    
    
    kBirailSrf = None
    
    
    kBlend = None
    
    
    kBlendColorSet = None
    
    
    kBlendColors = None
    
    
    kBlendDevice = None
    
    
    kBlendManip = None
    
    
    kBlendNodeAdditiveRotation = None
    
    
    kBlendNodeAdditiveScale = None
    
    
    kBlendNodeBase = None
    
    
    kBlendNodeBoolean = None
    
    
    kBlendNodeDouble = None
    
    
    kBlendNodeDoubleAngle = None
    
    
    kBlendNodeDoubleLinear = None
    
    
    kBlendNodeEnum = None
    
    
    kBlendNodeFloat = None
    
    
    kBlendNodeFloatAngle = None
    
    
    kBlendNodeFloatLinear = None
    
    
    kBlendNodeInt16 = None
    
    
    kBlendNodeInt32 = None
    
    
    kBlendShape = None
    
    
    kBlendTwoAttr = None
    
    
    kBlendWeighted = None
    
    
    kBlindData = None
    
    
    kBlindDataTemplate = None
    
    
    kBlinn = None
    
    
    kBlinnMaterial = None
    
    
    kBoundary = None
    
    
    kBox = None
    
    
    kBoxData = None
    
    
    kBrownian = None
    
    
    kBrush = None
    
    
    kBulge = None
    
    
    kBulgeLattice = None
    
    
    kBump = None
    
    
    kBump3d = None
    
    
    kButtonManip = None
    
    
    kCacheBase = None
    
    
    kCacheBlend = None
    
    
    kCacheFile = None
    
    
    kCacheTrack = None
    
    
    kCacheableNode = None
    
    
    kCamera = None
    
    
    kCameraManip = None
    
    
    kCameraPlaneManip = None
    
    
    kCameraSet = None
    
    
    kCameraView = None
    
    
    kCenterManip = None
    
    
    kChainToSpline = None
    
    
    kCharacter = None
    
    
    kCharacterMap = None
    
    
    kCharacterMappingData = None
    
    
    kCharacterOffset = None
    
    
    kChecker = None
    
    
    kChoice = None
    
    
    kChooser = None
    
    
    kCircle = None
    
    
    kCircleManip = None
    
    
    kCirclePointManip = None
    
    
    kCircleSweepManip = None
    
    
    kClampColor = None
    
    
    kClip = None
    
    
    kClipLibrary = None
    
    
    kClipScheduler = None
    
    
    kCloseCurve = None
    
    
    kCloseSurface = None
    
    
    kClosestPointOnMesh = None
    
    
    kClosestPointOnSurface = None
    
    
    kCloth = None
    
    
    kCloud = None
    
    
    kCluster = None
    
    
    kClusterFilter = None
    
    
    kClusterFlexor = None
    
    
    kCoiManip = None
    
    
    kCollision = None
    
    
    kColorBackground = None
    
    
    kColorProfile = None
    
    
    kCommCornerManip = None
    
    
    kCommCornerOperManip = None
    
    
    kCommEdgeOperManip = None
    
    
    kCommEdgePtManip = None
    
    
    kCommEdgeSegmentManip = None
    
    
    kComponent = None
    
    
    kComponentListData = None
    
    
    kComponentManip = None
    
    
    kCompoundAttribute = None
    
    
    kConcentricProjectionManip = None
    
    
    kCondition = None
    
    
    kCone = None
    
    
    kConstraint = None
    
    
    kContainer = None
    
    
    kContainerBase = None
    
    
    kContrast = None
    
    
    kControl = None
    
    
    kCopyColorSet = None
    
    
    kCopyUVSet = None
    
    
    kCpManip = None
    
    
    kCrater = None
    
    
    kCreate = None
    
    
    kCreateBPManip = None
    
    
    kCreateBezierManip = None
    
    
    kCreateCVManip = None
    
    
    kCreateColorSet = None
    
    
    kCreateEPManip = None
    
    
    kCreateSectionManip = None
    
    
    kCreateUVSet = None
    
    
    kCrossSectionEditManip = None
    
    
    kCrossSectionManager = None
    
    
    kCubicProjectionManip = None
    
    
    kCurve = None
    
    
    kCurveCVComponent = None
    
    
    kCurveCurveIntersect = None
    
    
    kCurveEPComponent = None
    
    
    kCurveEdManip = None
    
    
    kCurveFromMeshCoM = None
    
    
    kCurveFromMeshEdge = None
    
    
    kCurveFromSubdivEdge = None
    
    
    kCurveFromSubdivFace = None
    
    
    kCurveFromSurface = None
    
    
    kCurveFromSurfaceBnd = None
    
    
    kCurveFromSurfaceCoS = None
    
    
    kCurveFromSurfaceIso = None
    
    
    kCurveInfo = None
    
    
    kCurveKnotComponent = None
    
    
    kCurveNormalizerAngle = None
    
    
    kCurveNormalizerLinear = None
    
    
    kCurveParamComponent = None
    
    
    kCurveSegmentManip = None
    
    
    kCurveVarGroup = None
    
    
    kCylinder = None
    
    
    kCylindricalProjectionManip = None
    
    
    kDOF = None
    
    
    kDPbirailSrf = None
    
    
    kDagContainer = None
    
    
    kDagNode = None
    
    
    kDagPose = None
    
    
    kDagSelectionItem = None
    
    
    kData = None
    
    
    kData2Double = None
    
    
    kData2Float = None
    
    
    kData2Int = None
    
    
    kData2Long = None
    
    
    kData2Short = None
    
    
    kData3Double = None
    
    
    kData3Float = None
    
    
    kData3Int = None
    
    
    kData3Long = None
    
    
    kData3Short = None
    
    
    kData4Double = None
    
    
    kDblTrsManip = None
    
    
    kDecayRegionCapComponent = None
    
    
    kDecayRegionComponent = None
    
    
    kDefaultLightList = None
    
    
    kDeformBend = None
    
    
    kDeformBendManip = None
    
    
    kDeformFlare = None
    
    
    kDeformFlareManip = None
    
    
    kDeformFunc = None
    
    
    kDeformSine = None
    
    
    kDeformSineManip = None
    
    
    kDeformSquash = None
    
    
    kDeformSquashManip = None
    
    
    kDeformTwist = None
    
    
    kDeformTwistManip = None
    
    
    kDeformWave = None
    
    
    kDeformWaveManip = None
    
    
    kDeleteColorSet = None
    
    
    kDeleteComponent = None
    
    
    kDeleteUVSet = None
    
    
    kDependencyNode = None
    
    
    kDetachCurve = None
    
    
    kDetachSurface = None
    
    
    kDiffuseMaterial = None
    
    
    kDimension = None
    
    
    kDimensionManip = None
    
    
    kDirectedDisc = None
    
    
    kDirectionManip = None
    
    
    kDirectionalLight = None
    
    
    kDiscManip = None
    
    
    kDiskCache = None
    
    
    kDispatchCompute = None
    
    
    kDisplacementShader = None
    
    
    kDisplayLayer = None
    
    
    kDisplayLayerManager = None
    
    
    kDistance = None
    
    
    kDistanceBetween = None
    
    
    kDistanceManip = None
    
    
    kDofManip = None
    
    
    kDoubleAngleAttribute = None
    
    
    kDoubleArrayData = None
    
    
    kDoubleIndexedComponent = None
    
    
    kDoubleLinearAttribute = None
    
    
    kDoubleShadingSwitch = None
    
    
    kDrag = None
    
    
    kDropOffFunction = None
    
    
    kDropoffLocator = None
    
    
    kDropoffManip = None
    
    
    kDummy = None
    
    
    kDummyConnectable = None
    
    
    kDynAirManip = None
    
    
    kDynArrayAttrsData = None
    
    
    kDynAttenuationManip = None
    
    
    kDynBase = None
    
    
    kDynBaseFieldManip = None
    
    
    kDynEmitterManip = None
    
    
    kDynFieldsManip = None
    
    
    kDynGlobals = None
    
    
    kDynNewtonManip = None
    
    
    kDynParticleSetComponent = None
    
    
    kDynSpreadManip = None
    
    
    kDynSweptGeometryData = None
    
    
    kDynTurbulenceManip = None
    
    
    kDynamicConstraint = None
    
    
    kDynamicsController = None
    
    
    kEdgeComponent = None
    
    
    kEditCurve = None
    
    
    kEditCurveManip = None
    
    
    kEmitter = None
    
    
    kEnableManip = None
    
    
    kEnumAttribute = None
    
    
    kEnvBall = None
    
    
    kEnvChrome = None
    
    
    kEnvCube = None
    
    
    kEnvFacade = None
    
    
    kEnvFogMaterial = None
    
    
    kEnvFogShape = None
    
    
    kEnvSky = None
    
    
    kEnvSphere = None
    
    
    kExplodeNurbsShell = None
    
    
    kExpression = None
    
    
    kExtendCurve = None
    
    
    kExtendCurveDistanceManip = None
    
    
    kExtendSurface = None
    
    
    kExtendSurfaceDistanceManip = None
    
    
    kExtract = None
    
    
    kExtrude = None
    
    
    kExtrudeManip = None
    
    
    kFFD = None
    
    
    kFFblendSrf = None
    
    
    kFFfilletSrf = None
    
    
    kFacade = None
    
    
    kFfdDualBase = None
    
    
    kField = None
    
    
    kFileBackground = None
    
    
    kFileTexture = None
    
    
    kFilletCurve = None
    
    
    kFilter = None
    
    
    kFilterClosestSample = None
    
    
    kFilterEuler = None
    
    
    kFilterSimplify = None
    
    
    kFitBspline = None
    
    
    kFixedLineManip = None
    
    
    kFlexor = None
    
    
    kFloatAngleAttribute = None
    
    
    kFloatArrayData = None
    
    
    kFloatLinearAttribute = None
    
    
    kFloatMatrixAttribute = None
    
    
    kFloatVectorArrayData = None
    
    
    kFlow = None
    
    
    kFluid = None
    
    
    kFluidData = None
    
    
    kFluidEmitter = None
    
    
    kFluidGeom = None
    
    
    kFluidTexture2D = None
    
    
    kFluidTexture3D = None
    
    
    kFollicle = None
    
    
    kForceUpdateManip = None
    
    
    kFourByFourMatrix = None
    
    
    kFractal = None
    
    
    kFreePointManip = None
    
    
    kFreePointTriadManip = None
    
    
    kGammaCorrect = None
    
    
    kGenericAttribute = None
    
    
    kGeoConnectable = None
    
    
    kGeoConnector = None
    
    
    kGeometric = None
    
    
    kGeometryConstraint = None
    
    
    kGeometryData = None
    
    
    kGeometryFilt = None
    
    
    kGeometryOnLineManip = None
    
    
    kGeometryVarGroup = None
    
    
    kGlobalCacheControls = None
    
    
    kGlobalStitch = None
    
    
    kGranite = None
    
    
    kGravity = None
    
    
    kGrid = None
    
    
    kGroundPlane = None
    
    
    kGroupId = None
    
    
    kGroupParts = None
    
    
    kGuide = None
    
    
    kGuideLine = None
    
    
    kHairConstraint = None
    
    
    kHairSystem = None
    
    
    kHairTubeShader = None
    
    
    kHandleRotateManip = None
    
    
    kHardenPointCurve = None
    
    
    kHardwareReflectionMap = None
    
    
    kHardwareRenderGlobals = None
    
    
    kHardwareRenderingGlobals = None
    
    
    kHeightField = None
    
    
    kHikEffector = None
    
    
    kHikFKJoint = None
    
    
    kHikFloorContactMarker = None
    
    
    kHikGroundPlane = None
    
    
    kHikHandle = None
    
    
    kHikIKEffector = None
    
    
    kHikSolver = None
    
    
    kHistorySwitch = None
    
    
    kHsvToRgb = None
    
    
    kHwShaderNode = None
    
    
    kHyperGraphInfo = None
    
    
    kHyperLayout = None
    
    
    kHyperLayoutDG = None
    
    
    kHyperView = None
    
    
    kIkEffector = None
    
    
    kIkHandle = None
    
    
    kIkRPManip = None
    
    
    kIkSolver = None
    
    
    kIkSplineManip = None
    
    
    kIkSystem = None
    
    
    kIllustratorCurve = None
    
    
    kImageAdd = None
    
    
    kImageBlur = None
    
    
    kImageColorCorrect = None
    
    
    kImageData = None
    
    
    kImageDepth = None
    
    
    kImageDiff = None
    
    
    kImageDisplay = None
    
    
    kImageFilter = None
    
    
    kImageLoad = None
    
    
    kImageMotionBlur = None
    
    
    kImageMultiply = None
    
    
    kImageNetDest = None
    
    
    kImageNetSrc = None
    
    
    kImageOver = None
    
    
    kImagePlane = None
    
    
    kImageRender = None
    
    
    kImageSave = None
    
    
    kImageSource = None
    
    
    kImageUnder = None
    
    
    kImageView = None
    
    
    kImplicitCone = None
    
    
    kImplicitSphere = None
    
    
    kInsertKnotCrv = None
    
    
    kInsertKnotSrf = None
    
    
    kInstancer = None
    
    
    kIntArrayData = None
    
    
    kIntersectSurface = None
    
    
    kInvalid = None
    
    
    kIsoparmComponent = None
    
    
    kIsoparmManip = None
    
    
    kItemList = None
    
    
    kJiggleDeformer = None
    
    
    kJoint = None
    
    
    kJointCluster = None
    
    
    kJointClusterManip = None
    
    
    kJointTranslateManip = None
    
    
    kKeyframeDelta = None
    
    
    kKeyframeDeltaAddRemove = None
    
    
    kKeyframeDeltaBlockAddRemove = None
    
    
    kKeyframeDeltaBreakdown = None
    
    
    kKeyframeDeltaInfType = None
    
    
    kKeyframeDeltaMove = None
    
    
    kKeyframeDeltaScale = None
    
    
    kKeyframeDeltaTangent = None
    
    
    kKeyframeDeltaWeighted = None
    
    
    kKeyframeRegionManip = None
    
    
    kKeyingGroup = None
    
    
    kLambert = None
    
    
    kLambertMaterial = None
    
    
    kLast = None
    
    
    kLattice = None
    
    
    kLatticeComponent = None
    
    
    kLatticeData = None
    
    
    kLatticeGeom = None
    
    
    kLayeredShader = None
    
    
    kLayeredTexture = None
    
    
    kLeastSquares = None
    
    
    kLeather = None
    
    
    kLight = None
    
    
    kLightDataAttribute = None
    
    
    kLightFogMaterial = None
    
    
    kLightInfo = None
    
    
    kLightLink = None
    
    
    kLightList = None
    
    
    kLightManip = None
    
    
    kLightProjectionGeometry = None
    
    
    kLightSource = None
    
    
    kLightSourceMaterial = None
    
    
    kLimitManip = None
    
    
    kLineArrowManip = None
    
    
    kLineManip = None
    
    
    kLineModifier = None
    
    
    kLinearLight = None
    
    
    kLocator = None
    
    
    kLodGroup = None
    
    
    kLodThresholds = None
    
    
    kLookAt = None
    
    
    kLuminance = None
    
    
    kMCsolver = None
    
    
    kMPbirailSrf = None
    
    
    kMakeGroup = None
    
    
    kManip2DContainer = None
    
    
    kManipContainer = None
    
    
    kManipulator = None
    
    
    kManipulator2D = None
    
    
    kManipulator3D = None
    
    
    kMarble = None
    
    
    kMarker = None
    
    
    kMarkerManip = None
    
    
    kMaterial = None
    
    
    kMaterialFacade = None
    
    
    kMaterialInfo = None
    
    
    kMatrixAdd = None
    
    
    kMatrixAttribute = None
    
    
    kMatrixData = None
    
    
    kMatrixFloatData = None
    
    
    kMatrixHold = None
    
    
    kMatrixMult = None
    
    
    kMatrixPass = None
    
    
    kMatrixWtAdd = None
    
    
    kMembrane = None
    
    
    kMentalRayTexture = None
    
    
    kMergeVertsToolManip = None
    
    
    kMesh = None
    
    
    kMeshComponent = None
    
    
    kMeshData = None
    
    
    kMeshEdgeComponent = None
    
    
    kMeshFaceVertComponent = None
    
    
    kMeshFrEdgeComponent = None
    
    
    kMeshGeom = None
    
    
    kMeshMapComponent = None
    
    
    kMeshPolygonComponent = None
    
    
    kMeshVarGroup = None
    
    
    kMeshVertComponent = None
    
    
    kMeshVtxFaceComponent = None
    
    
    kMessageAttribute = None
    
    
    kMidModifier = None
    
    
    kMidModifierWithMatrix = None
    
    
    kModel = None
    
    
    kModifyEdgeBaseManip = None
    
    
    kModifyEdgeCrvManip = None
    
    
    kModifyEdgeManip = None
    
    
    kMotionPath = None
    
    
    kMotionPathManip = None
    
    
    kMountain = None
    
    
    kMoveUVShellManip2D = None
    
    
    kMoveVertexManip = None
    
    
    kMultDoubleLinear = None
    
    
    kMultiSubVertexComponent = None
    
    
    kMultilisterLight = None
    
    
    kMultiplyDivide = None
    
    
    kMute = None
    
    
    kNBase = None
    
    
    kNCloth = None
    
    
    kNComponent = None
    
    
    kNId = None
    
    
    kNIdData = None
    
    
    kNObject = None
    
    
    kNObjectData = None
    
    
    kNParticle = None
    
    
    kNRigid = None
    
    
    kNamedObject = None
    
    
    kNearestPointOnCurve = None
    
    
    kNewton = None
    
    
    kNoise = None
    
    
    kNonAmbientLight = None
    
    
    kNonDagSelectionItem = None
    
    
    kNonExtendedLight = None
    
    
    kNonLinear = None
    
    
    kNormalConstraint = None
    
    
    kNucleus = None
    
    
    kNumericAttribute = None
    
    
    kNumericData = None
    
    
    kNurbsBoolean = None
    
    
    kNurbsCircular2PtArc = None
    
    
    kNurbsCircular3PtArc = None
    
    
    kNurbsCube = None
    
    
    kNurbsCurve = None
    
    
    kNurbsCurveData = None
    
    
    kNurbsCurveGeom = None
    
    
    kNurbsCurveToBezier = None
    
    
    kNurbsPlane = None
    
    
    kNurbsSquare = None
    
    
    kNurbsSurface = None
    
    
    kNurbsSurfaceData = None
    
    
    kNurbsSurfaceGeom = None
    
    
    kNurbsTesselate = None
    
    
    kNurbsToSubdiv = None
    
    
    kObjectAttrFilter = None
    
    
    kObjectBinFilter = None
    
    
    kObjectFilter = None
    
    
    kObjectMultiFilter = None
    
    
    kObjectNameFilter = None
    
    
    kObjectRenderFilter = None
    
    
    kObjectScriptFilter = None
    
    
    kObjectTypeFilter = None
    
    
    kOcean = None
    
    
    kOceanShader = None
    
    
    kOffsetCos = None
    
    
    kOffsetCosManip = None
    
    
    kOffsetCurve = None
    
    
    kOffsetCurveManip = None
    
    
    kOffsetSurface = None
    
    
    kOffsetSurfaceManip = None
    
    
    kOldGeometryConstraint = None
    
    
    kOpticalFX = None
    
    
    kOrientConstraint = None
    
    
    kOrientationComponent = None
    
    
    kOrientationLocator = None
    
    
    kOrientationMarker = None
    
    
    kOrthoGrid = None
    
    
    kPASolver = None
    
    
    kPairBlend = None
    
    
    kParamDimension = None
    
    
    kParentConstraint = None
    
    
    kParticle = None
    
    
    kParticleAgeMapper = None
    
    
    kParticleCloud = None
    
    
    kParticleColorMapper = None
    
    
    kParticleIncandecenceMapper = None
    
    
    kParticleSamplerInfo = None
    
    
    kParticleTransparencyMapper = None
    
    
    kPartition = None
    
    
    kPassContributionMap = None
    
    
    kPfxGeometry = None
    
    
    kPfxHair = None
    
    
    kPfxToon = None
    
    
    kPhong = None
    
    
    kPhongExplorer = None
    
    
    kPhongMaterial = None
    
    
    kPivotComponent = None
    
    
    kPivotManip2D = None
    
    
    kPlace2dTexture = None
    
    
    kPlace3dTexture = None
    
    
    kPlanarProjectionManip = None
    
    
    kPlanarTrimSrf = None
    
    
    kPlane = None
    
    
    kPlugin = None
    
    
    kPluginCameraSet = None
    
    
    kPluginConstraintNode = None
    
    
    kPluginData = None
    
    
    kPluginDeformerNode = None
    
    
    kPluginDependNode = None
    
    
    kPluginEmitterNode = None
    
    
    kPluginFieldNode = None
    
    
    kPluginGeometryData = None
    
    
    kPluginHardwareShader = None
    
    
    kPluginHwShaderNode = None
    
    
    kPluginIkSolver = None
    
    
    kPluginImagePlaneNode = None
    
    
    kPluginLocatorNode = None
    
    
    kPluginManipContainer = None
    
    
    kPluginManipulatorNode = None
    
    
    kPluginObjectSet = None
    
    
    kPluginParticleAttributeMapperNode = None
    
    
    kPluginShape = None
    
    
    kPluginSpringNode = None
    
    
    kPluginTransformNode = None
    
    
    kPlusMinusAverage = None
    
    
    kPointArrayData = None
    
    
    kPointConstraint = None
    
    
    kPointLight = None
    
    
    kPointManip = None
    
    
    kPointMatrixMult = None
    
    
    kPointOnCurveInfo = None
    
    
    kPointOnCurveManip = None
    
    
    kPointOnLineManip = None
    
    
    kPointOnPolyConstraint = None
    
    
    kPointOnSurfaceInfo = None
    
    
    kPointOnSurfaceManip = None
    
    
    kPoleVectorConstraint = None
    
    
    kPolyAppend = None
    
    
    kPolyAppendVertex = None
    
    
    kPolyArrow = None
    
    
    kPolyAutoProj = None
    
    
    kPolyAutoProjManip = None
    
    
    kPolyAverageVertex = None
    
    
    kPolyBevel = None
    
    
    kPolyBlindData = None
    
    
    kPolyBoolOp = None
    
    
    kPolyBridgeEdge = None
    
    
    kPolyChipOff = None
    
    
    kPolyCloseBorder = None
    
    
    kPolyCollapseEdge = None
    
    
    kPolyCollapseF = None
    
    
    kPolyColorDel = None
    
    
    kPolyColorMod = None
    
    
    kPolyColorPerVertex = None
    
    
    kPolyComponentData = None
    
    
    kPolyCone = None
    
    
    kPolyConnectComponents = None
    
    
    kPolyCreaseEdge = None
    
    
    kPolyCreateFacet = None
    
    
    kPolyCreateToolManip = None
    
    
    kPolyCreator = None
    
    
    kPolyCube = None
    
    
    kPolyCut = None
    
    
    kPolyCutManip = None
    
    
    kPolyCutManipContainer = None
    
    
    kPolyCylProj = None
    
    
    kPolyCylinder = None
    
    
    kPolyDelEdge = None
    
    
    kPolyDelFacet = None
    
    
    kPolyDelVertex = None
    
    
    kPolyDuplicateEdge = None
    
    
    kPolyEdgeToCurve = None
    
    
    kPolyExtrudeEdge = None
    
    
    kPolyExtrudeFacet = None
    
    
    kPolyExtrudeManip = None
    
    
    kPolyExtrudeManipContainer = None
    
    
    kPolyExtrudeVertex = None
    
    
    kPolyFlipEdge = None
    
    
    kPolyFlipUV = None
    
    
    kPolyHelix = None
    
    
    kPolyHoleFace = None
    
    
    kPolyLayoutUV = None
    
    
    kPolyMapCut = None
    
    
    kPolyMapDel = None
    
    
    kPolyMapSew = None
    
    
    kPolyMapSewMove = None
    
    
    kPolyMappingManip = None
    
    
    kPolyMergeEdge = None
    
    
    kPolyMergeFacet = None
    
    
    kPolyMergeUV = None
    
    
    kPolyMergeVert = None
    
    
    kPolyMesh = None
    
    
    kPolyMirror = None
    
    
    kPolyModifierManip = None
    
    
    kPolyMoveEdge = None
    
    
    kPolyMoveFacet = None
    
    
    kPolyMoveFacetUV = None
    
    
    kPolyMoveUV = None
    
    
    kPolyMoveUVManip = None
    
    
    kPolyMoveVertex = None
    
    
    kPolyMoveVertexManip = None
    
    
    kPolyMoveVertexUV = None
    
    
    kPolyNormal = None
    
    
    kPolyNormalPerVertex = None
    
    
    kPolyNormalizeUV = None
    
    
    kPolyPipe = None
    
    
    kPolyPlanProj = None
    
    
    kPolyPlatonicSolid = None
    
    
    kPolyPoke = None
    
    
    kPolyPokeManip = None
    
    
    kPolyPrimitive = None
    
    
    kPolyPrimitiveMisc = None
    
    
    kPolyPrism = None
    
    
    kPolyProj = None
    
    
    kPolyProjectCurve = None
    
    
    kPolyProjectionManip = None
    
    
    kPolyPyramid = None
    
    
    kPolyQuad = None
    
    
    kPolyReduce = None
    
    
    kPolySelectEditFeedbackManip = None
    
    
    kPolySeparate = None
    
    
    kPolySewEdge = None
    
    
    kPolySmooth = None
    
    
    kPolySmoothFacet = None
    
    
    kPolySmoothProxy = None
    
    
    kPolySoftEdge = None
    
    
    kPolySphProj = None
    
    
    kPolySphere = None
    
    
    kPolySpinEdge = None
    
    
    kPolySplit = None
    
    
    kPolySplitEdge = None
    
    
    kPolySplitRing = None
    
    
    kPolySplitToolManip = None
    
    
    kPolySplitVert = None
    
    
    kPolyStraightenUVBorder = None
    
    
    kPolySubdEdge = None
    
    
    kPolySubdFacet = None
    
    
    kPolyToSubdiv = None
    
    
    kPolyToolFeedbackManip = None
    
    
    kPolyToolFeedbackShape = None
    
    
    kPolyTorus = None
    
    
    kPolyTransfer = None
    
    
    kPolyTriangulate = None
    
    
    kPolyTweak = None
    
    
    kPolyTweakUV = None
    
    
    kPolyUVRectangle = None
    
    
    kPolyUnite = None
    
    
    kPolyVertexNormalManip = None
    
    
    kPolyWedgeFace = None
    
    
    kPositionMarker = None
    
    
    kPostProcessList = None
    
    
    kPrecompExport = None
    
    
    kPrimitive = None
    
    
    kProjectCurve = None
    
    
    kProjectTangent = None
    
    
    kProjectTangentManip = None
    
    
    kProjection = None
    
    
    kProjectionManip = None
    
    
    kProjectionMultiManip = None
    
    
    kProjectionUVManip = None
    
    
    kPropModManip = None
    
    
    kPropMoveTriadManip = None
    
    
    kProxy = None
    
    
    kProxyManager = None
    
    
    kPsdFileTexture = None
    
    
    kQuadPtOnLineManip = None
    
    
    kQuadShadingSwitch = None
    
    
    kRBFsurface = None
    
    
    kRPsolver = None
    
    
    kRadial = None
    
    
    kRadius = None
    
    
    kRamp = None
    
    
    kRampBackground = None
    
    
    kRampShader = None
    
    
    kRbfSrfManip = None
    
    
    kRebuildCurve = None
    
    
    kRebuildSurface = None
    
    
    kRecord = None
    
    
    kReference = None
    
    
    kReflect = None
    
    
    kRemapColor = None
    
    
    kRemapHsv = None
    
    
    kRemapValue = None
    
    
    kRenderBox = None
    
    
    kRenderCone = None
    
    
    kRenderGlobals = None
    
    
    kRenderGlobalsList = None
    
    
    kRenderLayer = None
    
    
    kRenderLayerManager = None
    
    
    kRenderPass = None
    
    
    kRenderPassSet = None
    
    
    kRenderQuality = None
    
    
    kRenderRect = None
    
    
    kRenderSetup = None
    
    
    kRenderSphere = None
    
    
    kRenderTarget = None
    
    
    kRenderUtilityList = None
    
    
    kRenderedImageSource = None
    
    
    kRenderingList = None
    
    
    kResolution = None
    
    
    kResultCurve = None
    
    
    kResultCurveTimeToAngular = None
    
    
    kResultCurveTimeToDistance = None
    
    
    kResultCurveTimeToTime = None
    
    
    kResultCurveTimeToUnitless = None
    
    
    kReverse = None
    
    
    kReverseCrvManip = None
    
    
    kReverseCurve = None
    
    
    kReverseCurveManip = None
    
    
    kReverseSurface = None
    
    
    kReverseSurfaceManip = None
    
    
    kRevolve = None
    
    
    kRevolveManip = None
    
    
    kRevolvedPrimitive = None
    
    
    kRevolvedPrimitiveManip = None
    
    
    kRgbToHsv = None
    
    
    kRigid = None
    
    
    kRigidConstraint = None
    
    
    kRigidDeform = None
    
    
    kRigidSolver = None
    
    
    kRock = None
    
    
    kRotateBoxManip = None
    
    
    kRotateLimitsManip = None
    
    
    kRotateManip = None
    
    
    kRotateUVManip2D = None
    
    
    kRoundConstantRadius = None
    
    
    kRoundConstantRadiusManip = None
    
    
    kRoundRadiusCrvManip = None
    
    
    kRoundRadiusManip = None
    
    
    kSCsolver = None
    
    
    kSPbirailSrf = None
    
    
    kSamplerInfo = None
    
    
    kScaleConstraint = None
    
    
    kScaleLimitsManip = None
    
    
    kScaleManip = None
    
    
    kScalePointManip = None
    
    
    kScaleUVManip2D = None
    
    
    kScalingBoxManip = None
    
    
    kScreenAlignedCircleManip = None
    
    
    kScript = None
    
    
    kScriptManip = None
    
    
    kSculpt = None
    
    
    kSectionManip = None
    
    
    kSelectionItem = None
    
    
    kSelectionList = None
    
    
    kSelectionListData = None
    
    
    kSelectionListOperator = None
    
    
    kSequenceManager = None
    
    
    kSequencer = None
    
    
    kSet = None
    
    
    kSetGroupComponent = None
    
    
    kSetRange = None
    
    
    kSfRevolveManip = None
    
    
    kShaderGlow = None
    
    
    kShaderList = None
    
    
    kShadingEffect = None
    
    
    kShadingEngine = None
    
    
    kShadingMap = None
    
    
    kShape = None
    
    
    kShapeFragment = None
    
    
    kShot = None
    
    
    kSimpleVolumeShader = None
    
    
    kSingleIndexedComponent = None
    
    
    kSingleShadingSwitch = None
    
    
    kSketchPlane = None
    
    
    kSkin = None
    
    
    kSkinBinding = None
    
    
    kSkinClusterFilter = None
    
    
    kSkinShader = None
    
    
    kSl60 = None
    
    
    kSmear = None
    
    
    kSmoothCurve = None
    
    
    kSmoothTangentSrf = None
    
    
    kSnapshot = None
    
    
    kSnapshotPath = None
    
    
    kSnapshotShape = None
    
    
    kSnow = None
    
    
    kSoftMod = None
    
    
    kSoftModFilter = None
    
    
    kSoftModManip = None
    
    
    kSolidFractal = None
    
    
    kSphere = None
    
    
    kSphereData = None
    
    
    kSphericalProjectionManip = None
    
    
    kSplineSolver = None
    
    
    kSpotCylinderManip = None
    
    
    kSpotLight = None
    
    
    kSpotManip = None
    
    
    kSpring = None
    
    
    kSprite = None
    
    
    kSquareSrf = None
    
    
    kSquareSrfManip = None
    
    
    kStateManip = None
    
    
    kStencil = None
    
    
    kStereoCameraMaster = None
    
    
    kStitchAsNurbsShell = None
    
    
    kStitchSrf = None
    
    
    kStitchSrfManip = None
    
    
    kStoryBoard = None
    
    
    kStringArrayData = None
    
    
    kStringData = None
    
    
    kStringShadingSwitch = None
    
    
    kStroke = None
    
    
    kStrokeGlobals = None
    
    
    kStucco = None
    
    
    kStudioClearCoat = None
    
    
    kStyleCurve = None
    
    
    kSubCurve = None
    
    
    kSubSurface = None
    
    
    kSubVertexComponent = None
    
    
    kSubdAddTopology = None
    
    
    kSubdAutoProj = None
    
    
    kSubdBlindData = None
    
    
    kSubdBoolean = None
    
    
    kSubdCleanTopology = None
    
    
    kSubdCloseBorder = None
    
    
    kSubdDelFace = None
    
    
    kSubdExtrudeFace = None
    
    
    kSubdHierBlind = None
    
    
    kSubdLayoutUV = None
    
    
    kSubdMapCut = None
    
    
    kSubdMapSewMove = None
    
    
    kSubdMappingManip = None
    
    
    kSubdMergeVert = None
    
    
    kSubdModifier = None
    
    
    kSubdModifyEdge = None
    
    
    kSubdMoveEdge = None
    
    
    kSubdMoveFace = None
    
    
    kSubdMoveVertex = None
    
    
    kSubdPlanProj = None
    
    
    kSubdProjectionManip = None
    
    
    kSubdSplitFace = None
    
    
    kSubdSubdivideFace = None
    
    
    kSubdTweak = None
    
    
    kSubdTweakUV = None
    
    
    kSubdiv = None
    
    
    kSubdivCVComponent = None
    
    
    kSubdivCollapse = None
    
    
    kSubdivCompId = None
    
    
    kSubdivData = None
    
    
    kSubdivEdgeComponent = None
    
    
    kSubdivFaceComponent = None
    
    
    kSubdivGeom = None
    
    
    kSubdivMapComponent = None
    
    
    kSubdivReverseFaces = None
    
    
    kSubdivSurfaceVarGroup = None
    
    
    kSubdivToNurbs = None
    
    
    kSubdivToPoly = None
    
    
    kSummaryObject = None
    
    
    kSuper = None
    
    
    kSurface = None
    
    
    kSurfaceCVComponent = None
    
    
    kSurfaceEPComponent = None
    
    
    kSurfaceEdManip = None
    
    
    kSurfaceFaceComponent = None
    
    
    kSurfaceInfo = None
    
    
    kSurfaceKnotComponent = None
    
    
    kSurfaceLuminance = None
    
    
    kSurfaceRangeComponent = None
    
    
    kSurfaceShader = None
    
    
    kSurfaceVarGroup = None
    
    
    kSymmetryLocator = None
    
    
    kSymmetryMapCurve = None
    
    
    kSymmetryMapVector = None
    
    
    kTangentConstraint = None
    
    
    kTexLattice = None
    
    
    kTexLatticeDeformManip = None
    
    
    kTexSmoothManip = None
    
    
    kTexSmudgeUVManip = None
    
    
    kTextButtonManip = None
    
    
    kTextCurves = None
    
    
    kTextManip = None
    
    
    kTexture2d = None
    
    
    kTexture3d = None
    
    
    kTextureBakeSet = None
    
    
    kTextureEnv = None
    
    
    kTextureList = None
    
    
    kTextureManip3D = None
    
    
    kThreePointArcManip = None
    
    
    kTime = None
    
    
    kTimeAttribute = None
    
    
    kTimeFunction = None
    
    
    kTimeToUnitConversion = None
    
    
    kToggleManip = None
    
    
    kToggleOnLineManip = None
    
    
    kToonLineAttributes = None
    
    
    kTorus = None
    
    
    kTowPointManip = None
    
    
    kTowPointOnCurveManip = None
    
    
    kTowPointOnSurfaceManip = None
    
    
    kTransferAttributes = None
    
    
    kTransform = None
    
    
    kTransformBoxManip = None
    
    
    kTransformGeometry = None
    
    
    kTranslateBoxManip = None
    
    
    kTranslateLimitsManip = None
    
    
    kTranslateManip = None
    
    
    kTranslateManip2D = None
    
    
    kTranslateUVManip = None
    
    
    kTranslateUVManip2D = None
    
    
    kTriadManip = None
    
    
    kTrim = None
    
    
    kTrimLocator = None
    
    
    kTrimManip = None
    
    
    kTrimWithBoundaries = None
    
    
    kTriplanarProjectionManip = None
    
    
    kTripleIndexedComponent = None
    
    
    kTripleShadingSwitch = None
    
    
    kTrsInsertManip = None
    
    
    kTrsManip = None
    
    
    kTrsTransManip = None
    
    
    kTrsXformManip = None
    
    
    kTurbulence = None
    
    
    kTweak = None
    
    
    kTwoPointArcManip = None
    
    
    kTxSl = None
    
    
    kTypedAttribute = None
    
    
    kUInt64ArrayData = None
    
    
    kUVManip2D = None
    
    
    kUint64SingleIndexedComponent = None
    
    
    kUnderWorld = None
    
    
    kUniform = None
    
    
    kUnitAttribute = None
    
    
    kUnitConversion = None
    
    
    kUnitToTimeConversion = None
    
    
    kUnknown = None
    
    
    kUnknownDag = None
    
    
    kUnknownTransform = None
    
    
    kUntrim = None
    
    
    kUnused1 = None
    
    
    kUnused2 = None
    
    
    kUnused3 = None
    
    
    kUnused4 = None
    
    
    kUnused5 = None
    
    
    kUnused6 = None
    
    
    kUseBackground = None
    
    
    kUvChooser = None
    
    
    kVectorArrayData = None
    
    
    kVectorProduct = None
    
    
    kVertexBakeSet = None
    
    
    kVertexWeightSet = None
    
    
    kViewColorManager = None
    
    
    kViewManip = None
    
    
    kVolumeAxis = None
    
    
    kVolumeBindManip = None
    
    
    kVolumeFog = None
    
    
    kVolumeLight = None
    
    
    kVolumeNoise = None
    
    
    kVolumeShader = None
    
    
    kVortex = None
    
    
    kWater = None
    
    
    kWeightGeometryFilt = None
    
    
    kWire = None
    
    
    kWood = None
    
    
    kWorld = None
    
    
    kWrapFilter = None
    
    
    kWriteToColorBuffer = None
    
    
    kWriteToDepthBuffer = None
    
    
    kWriteToFrameBuffer = None
    
    
    kWriteToLabelBuffer = None
    
    
    kWriteToVectorBuffer = None
    
    
    kXformManip = None
    
    
    kXsectionSubdivEdit = None


class MUint64Array(object):
    """
    Array of MUint64 values.
    """
    
    
    
    def __add__(*args, **kwargs):
        """
        x.__add__(y) <==> x+y
        """
    
        pass
    
    
    def __contains__(*args, **kwargs):
        """
        x.__contains__(y) <==> y in x
        """
    
        pass
    
    
    def __delitem__(*args, **kwargs):
        """
        x.__delitem__(y) <==> del x[y]
        """
    
        pass
    
    
    def __getitem__(*args, **kwargs):
        """
        x.__getitem__(y) <==> x[y]
        """
    
        pass
    
    
    def __iadd__(*args, **kwargs):
        """
        x.__iadd__(y) <==> x+=y
        """
    
        pass
    
    
    def __imul__(*args, **kwargs):
        """
        x.__imul__(y) <==> x*=y
        """
    
        pass
    
    
    def __init__(*args, **kwargs):
        """
        x.__init__(...) initializes x; see x.__class__.__doc__ for signature
        """
    
        pass
    
    
    def __len__(*args, **kwargs):
        """
        x.__len__() <==> len(x)
        """
    
        pass
    
    
    def __mul__(*args, **kwargs):
        """
        x.__mul__(n) <==> x*n
        """
    
        pass
    
    
    def __repr__(*args, **kwargs):
        """
        x.__repr__() <==> repr(x)
        """
    
        pass
    
    
    def __rmul__(*args, **kwargs):
        """
        x.__rmul__(n) <==> n*x
        """
    
        pass
    
    
    def __setitem__(*args, **kwargs):
        """
        x.__setitem__(i, y) <==> x[i]=y
        """
    
        pass
    
    
    def __str__(*args, **kwargs):
        """
        x.__str__() <==> str(x)
        """
    
        pass
    
    
    def append(*args, **kwargs):
        """
        Add a value to the end of the array.
        """
    
        pass
    
    
    def clear(*args, **kwargs):
        """
        Remove all elements from the array.
        """
    
        pass
    
    
    def copy(*args, **kwargs):
        """
        Replace the array contents with that of another or of a compatible Python sequence.
        """
    
        pass
    
    
    def insert(*args, **kwargs):
        """
        Insert a new value into the array at the given index.
        """
    
        pass
    
    
    def remove(*args, **kwargs):
        """
        Remove an element from the array.
        """
    
        pass
    
    
    def setLength(*args, **kwargs):
        """
        Grow or shrink the array to contain a specific number of elements.
        """
    
        pass
    
    
    sizeIncrement = None
    
    __new__ = None


class MTypeId(object):
    """
    Stores a Maya object type identifier.
    """
    
    
    
    def __eq__(*args, **kwargs):
        """
        x.__eq__(y) <==> x==y
        """
    
        pass
    
    
    def __ge__(*args, **kwargs):
        """
        x.__ge__(y) <==> x>=y
        """
    
        pass
    
    
    def __gt__(*args, **kwargs):
        """
        x.__gt__(y) <==> x>y
        """
    
        pass
    
    
    def __init__(*args, **kwargs):
        """
        x.__init__(...) initializes x; see x.__class__.__doc__ for signature
        """
    
        pass
    
    
    def __le__(*args, **kwargs):
        """
        x.__le__(y) <==> x<=y
        """
    
        pass
    
    
    def __lt__(*args, **kwargs):
        """
        x.__lt__(y) <==> x<y
        """
    
        pass
    
    
    def __ne__(*args, **kwargs):
        """
        x.__ne__(y) <==> x!=y
        """
    
        pass
    
    
    def __repr__(*args, **kwargs):
        """
        x.__repr__() <==> repr(x)
        """
    
        pass
    
    
    def __str__(*args, **kwargs):
        """
        x.__str__() <==> str(x)
        """
    
        pass
    
    
    def id(*args, **kwargs):
        """
        Returns the type id as a long.
        """
    
        pass
    
    
    __new__ = None


class MDagPath(object):
    """
    Path to a DAG node from the top of the DAG.
    """
    
    
    
    def __eq__(*args, **kwargs):
        """
        x.__eq__(y) <==> x==y
        """
    
        pass
    
    
    def __ge__(*args, **kwargs):
        """
        x.__ge__(y) <==> x>=y
        """
    
        pass
    
    
    def __gt__(*args, **kwargs):
        """
        x.__gt__(y) <==> x>y
        """
    
        pass
    
    
    def __init__(*args, **kwargs):
        """
        x.__init__(...) initializes x; see x.__class__.__doc__ for signature
        """
    
        pass
    
    
    def __le__(*args, **kwargs):
        """
        x.__le__(y) <==> x<=y
        """
    
        pass
    
    
    def __lt__(*args, **kwargs):
        """
        x.__lt__(y) <==> x<y
        """
    
        pass
    
    
    def __ne__(*args, **kwargs):
        """
        x.__ne__(y) <==> x!=y
        """
    
        pass
    
    
    def __str__(*args, **kwargs):
        """
        x.__str__() <==> str(x)
        """
    
        pass
    
    
    def apiType(*args, **kwargs):
        """
        Returns the type of the object at the end of the path.
        """
    
        pass
    
    
    def child(*args, **kwargs):
        """
        Returns the specified child of the object at the end of the path.
        """
    
        pass
    
    
    def childCount(*args, **kwargs):
        """
        Returns the number of objects parented directly beneath the object at the end of the path.
        """
    
        pass
    
    
    def exclusiveMatrix(*args, **kwargs):
        """
        Returns the matrix for all transforms in the path, excluding the end object.
        """
    
        pass
    
    
    def exclusiveMatrixInverse(*args, **kwargs):
        """
        Returns the inverse of exclusiveMatrix().
        """
    
        pass
    
    
    def extendToShape(*args, **kwargs):
        """
        Extends the path to the specified shape node parented directly beneath the transform at the current end of the path.
        """
    
        pass
    
    
    def fullPathName(*args, **kwargs):
        """
        Returns a string representation of the path from the DAG root to the path's last node.
        """
    
        pass
    
    
    def getPath(*args, **kwargs):
        """
        Returns the specified sub-path of this path.
        """
    
        pass
    
    
    def hasFn(*args, **kwargs):
        """
        Returns True if the object at the end of the path supports the given function set.
        """
    
        pass
    
    
    def inclusiveMatrix(*args, **kwargs):
        """
        Returns the matrix for all transforms in the path, including the end object, if it is a transform.
        """
    
        pass
    
    
    def inclusiveMatrixInverse(*args, **kwargs):
        """
        Returns the inverse of inclusiveMatrix().
        """
    
        pass
    
    
    def instanceNumber(*args, **kwargs):
        """
        Returns the instance number of this path to the object at the end.
        """
    
        pass
    
    
    def isInstanced(*args, **kwargs):
        """
        Returns True if the object at the end of the path can be reached by more than one path.
        """
    
        pass
    
    
    def isValid(*args, **kwargs):
        """
        Returns True if this is a valid path.
        """
    
        pass
    
    
    def length(*args, **kwargs):
        """
        Returns the number of nodes on the path, not including the DAG's root node.
        """
    
        pass
    
    
    def node(*args, **kwargs):
        """
        Returns the DAG node at the end of the path.
        """
    
        pass
    
    
    def numberOfShapesDirectlyBelow(*args, **kwargs):
        """
        Returns the number of shape nodes parented directly beneath the transform at the end of the path.
        """
    
        pass
    
    
    def partialPathName(*args, **kwargs):
        """
        Returns the minimum string representation which will uniquely identify the path.
        """
    
        pass
    
    
    def pathCount(*args, **kwargs):
        """
        Returns the number of sub-paths which make up this path.
        """
    
        pass
    
    
    def pop(*args, **kwargs):
        """
        Removes objects from the end of the path.
        """
    
        pass
    
    
    def push(*args, **kwargs):
        """
        Extends the path to the specified child object, which must be parented directly beneath the object currently at the end of the path.
        """
    
        pass
    
    
    def set(*args, **kwargs):
        """
        Replaces the current path held by this object with another.
        """
    
        pass
    
    
    def transform(*args, **kwargs):
        """
        Returns the last transform node on the path.
        """
    
        pass
    
    
    def getAPathTo(*args, **kwargs):
        """
        Returns the first path found to the given node.
        """
    
        pass
    
    
    def getAllPathsTo(*args, **kwargs):
        """
        Returns all paths to the given node.
        """
    
        pass
    
    
    __new__ = None


class MDGContext(object):
    """
    Dependency graph context.
    """
    
    
    
    def __init__(*args, **kwargs):
        """
        x.__init__(...) initializes x; see x.__class__.__doc__ for signature
        """
    
        pass
    
    
    def getTime(*args, **kwargs):
        """
        Returns the time at which this context is set to evaluate.
        """
    
        pass
    
    
    def isNormal(*args, **kwargs):
        """
        Returns True if the context is set to evaluate normally. Returns False if the context is set to evaluate at a specific time.
        """
    
        pass
    
    
    __new__ = None
    
    
    kNormal = None


class MFnMesh(object):
    """
    Function set for operation on meshes (polygonal surfaces).
    """
    
    
    
    def __init__(*args, **kwargs):
        """
        x.__init__(...) initializes x; see x.__class__.__doc__ for signature
        """
    
        pass
    
    
    def getFloatPoints(*args, **kwargs):
        """
        Returns an MFloatPointArray containing the mesh's points.
        """
    
        pass
    
    
    __new__ = None
    
    
    kAlpha = None
    
    
    kDifference = None
    
    
    kInternalPoint = None
    
    
    kIntersection = None
    
    
    kInvalid = None
    
    
    kOnEdge = None
    
    
    kRGB = None
    
    
    kRGBA = None
    
    
    kUnion = None


class MFnBase(object):
    """
    Base class for function sets.
    """
    
    
    
    def __init__(*args, **kwargs):
        """
        x.__init__(...) initializes x; see x.__class__.__doc__ for signature
        """
    
        pass
    
    
    def hasObj(*args, **kwargs):
        """
        Returns True if the function set is compatible with the specified Maya object.
        """
    
        pass
    
    
    def object(*args, **kwargs):
        """
        Returns a reference to the object to which the function set is currently attached, or MObject.kNullObj if none.
        """
    
        pass
    
    
    def setObject(*args, **kwargs):
        """
        Attaches the function set to the specified Maya object.
        """
    
        pass
    
    
    def type(*args, **kwargs):
        """
        Returns the type of the function set.
        """
    
        pass
    
    
    __new__ = None


class MUintArray(object):
    """
    Array of unsigned int values.
    """
    
    
    
    def __add__(*args, **kwargs):
        """
        x.__add__(y) <==> x+y
        """
    
        pass
    
    
    def __contains__(*args, **kwargs):
        """
        x.__contains__(y) <==> y in x
        """
    
        pass
    
    
    def __delitem__(*args, **kwargs):
        """
        x.__delitem__(y) <==> del x[y]
        """
    
        pass
    
    
    def __getitem__(*args, **kwargs):
        """
        x.__getitem__(y) <==> x[y]
        """
    
        pass
    
    
    def __iadd__(*args, **kwargs):
        """
        x.__iadd__(y) <==> x+=y
        """
    
        pass
    
    
    def __imul__(*args, **kwargs):
        """
        x.__imul__(y) <==> x*=y
        """
    
        pass
    
    
    def __init__(*args, **kwargs):
        """
        x.__init__(...) initializes x; see x.__class__.__doc__ for signature
        """
    
        pass
    
    
    def __len__(*args, **kwargs):
        """
        x.__len__() <==> len(x)
        """
    
        pass
    
    
    def __mul__(*args, **kwargs):
        """
        x.__mul__(n) <==> x*n
        """
    
        pass
    
    
    def __repr__(*args, **kwargs):
        """
        x.__repr__() <==> repr(x)
        """
    
        pass
    
    
    def __rmul__(*args, **kwargs):
        """
        x.__rmul__(n) <==> n*x
        """
    
        pass
    
    
    def __setitem__(*args, **kwargs):
        """
        x.__setitem__(i, y) <==> x[i]=y
        """
    
        pass
    
    
    def __str__(*args, **kwargs):
        """
        x.__str__() <==> str(x)
        """
    
        pass
    
    
    def append(*args, **kwargs):
        """
        Add a value to the end of the array.
        """
    
        pass
    
    
    def clear(*args, **kwargs):
        """
        Remove all elements from the array.
        """
    
        pass
    
    
    def copy(*args, **kwargs):
        """
        Replace the array contents with that of another or of a compatible Python sequence.
        """
    
        pass
    
    
    def insert(*args, **kwargs):
        """
        Insert a new value into the array at the given index.
        """
    
        pass
    
    
    def remove(*args, **kwargs):
        """
        Remove an element from the array.
        """
    
        pass
    
    
    def setLength(*args, **kwargs):
        """
        Grow or shrink the array to contain a specific number of elements.
        """
    
        pass
    
    
    sizeIncrement = None
    
    __new__ = None


class MSpace(object):
    """
    Static class providing coordinate space constants.
    """
    
    
    
    kInvalid = None
    
    
    kLast = None
    
    
    kObject = None
    
    
    kPostTransform = None
    
    
    kPreTransform = None
    
    
    kTransform = None
    
    
    kWorld = None


class MArgList(object):
    """
    Argument list for passing to commands.
    """
    
    
    
    def __init__(*args, **kwargs):
        """
        x.__init__(...) initializes x; see x.__class__.__doc__ for signature
        """
    
        pass
    
    
    def __len__(*args, **kwargs):
        """
        x.__len__() <==> len(x)
        """
    
        pass
    
    
    def addArg(*args, **kwargs):
        """
        Add an argument to the end of the arg list.
        """
    
        pass
    
    
    def asBool(*args, **kwargs):
        """
        Return an argument as a boolean.
        """
    
        pass
    
    
    def asFloat(*args, **kwargs):
        """
        Return an argument as a float.
        """
    
        pass
    
    
    def asInt(*args, **kwargs):
        """
        Return an argument as an integer.
        """
    
        pass
    
    
    def asIntArray(*args, **kwargs):
        """
        Return a sequence of arguments as an MIntArray.
        """
    
        pass
    
    
    def asString(*args, **kwargs):
        """
        Return an argument as a string.
        """
    
        pass
    
    
    def asStringArray(*args, **kwargs):
        """
        Return a sequence of arguments as a list of strings.
        """
    
        pass
    
    
    def flagIndex(*args, **kwargs):
        """
        Return index of first occurrence of specified flag.
        """
    
        pass
    
    
    def lastArgUsed(*args, **kwargs):
        """
        Return index of last argument used by the most recent as*() method.
        """
    
        pass
    
    
    __new__ = None
    
    
    kInvalidArgIndex = None


class MFnAttribute(MFnBase):
    """
    Base class for attribute functionsets.
    """
    
    
    
    def __init__(*args, **kwargs):
        """
        x.__init__(...) initializes x; see x.__class__.__doc__ for signature
        """
    
        pass
    
    
    def accepts(*args, **kwargs):
        """
        Returns True if this attribute can accept a connection of the given type.
        """
    
        pass
    
    
    def getAddAttrCmd(*args, **kwargs):
        """
        Returns a string containing a MEL 'addAttr' command capable of recreating the attribute.
        """
    
        pass
    
    
    affectsAppearance = None
    
    affectsWorldSpace = None
    
    array = None
    
    cached = None
    
    channelBox = None
    
    connectable = None
    
    disconnectBehavior = None
    
    dynamic = None
    
    extension = None
    
    hidden = None
    
    indeterminant = None
    
    indexMatters = None
    
    internal = None
    
    keyable = None
    
    name = None
    
    parent = None
    
    readable = None
    
    renderSource = None
    
    shortName = None
    
    storable = None
    
    usedAsColor = None
    
    usedAsFilename = None
    
    usesArrayDataBuilder = None
    
    worldSpace = None
    
    writable = None
    
    __new__ = None
    
    
    kDelete = None
    
    
    kNothing = None
    
    
    kReset = None


class MFnDependencyNode(MFnBase):
    """
    Function set for operating on dependency nodes.
    """
    
    
    
    def __init__(*args, **kwargs):
        """
        x.__init__(...) initializes x; see x.__class__.__doc__ for signature
        """
    
        pass
    
    
    def addAttribute(*args, **kwargs):
        """
        Adds a new dynamic attribute to the node.
        """
    
        pass
    
    
    def attribute(*args, **kwargs):
        """
        Returns an attribute of the node, given either its index or name.
        """
    
        pass
    
    
    def attributeClass(*args, **kwargs):
        """
        Returns the class of the specified attribute.
        """
    
        pass
    
    
    def attributeCount(*args, **kwargs):
        """
        Returns the number of attributes on the node.
        """
    
        pass
    
    
    def canBeWritten(*args, **kwargs):
        """
        Returns true if the node will be written to file.
        """
    
        pass
    
    
    def create(*args, **kwargs):
        """
        Creates a new node of the given type.
        """
    
        pass
    
    
    def dgCallbackIds(*args, **kwargs):
        """
        Returns DG timing information for a specific callback type, broken down by callbackId.
        """
    
        pass
    
    
    def dgCallbacks(*args, **kwargs):
        """
        Returns DG timing information broken down by callback type.
        """
    
        pass
    
    
    def dgTimer(*args, **kwargs):
        """
        Returns a specific DG timer metric for a given timer type.
        """
    
        pass
    
    
    def dgTimerOff(*args, **kwargs):
        """
        Turns DG timing off for this node.
        """
    
        pass
    
    
    def dgTimerOn(*args, **kwargs):
        """
        Turns DG timing on for this node.
        """
    
        pass
    
    
    def dgTimerQueryState(*args, **kwargs):
        """
        Returns the current DG timer state for this node.
        """
    
        pass
    
    
    def dgTimerReset(*args, **kwargs):
        """
        Resets all DG timers for this node.
        """
    
        pass
    
    
    def findAlias(*args, **kwargs):
        """
        Returns the attribute which has the given alias.
        """
    
        pass
    
    
    def findPlug(*args, **kwargs):
        """
        Returns a plug for the given attribute.
        """
    
        pass
    
    
    def getAffectedAttributes(*args, **kwargs):
        """
        Returns all of the attributes which are affected by the specified attribute.
        """
    
        pass
    
    
    def getAffectingAttributes(*args, **kwargs):
        """
        Returns all of the attributes which affect the specified attribute.
        """
    
        pass
    
    
    def getAliasAttr(*args, **kwargs):
        """
        Returns the node's alias attribute, which is a special attribute used to store information about the node's attribute aliases.
        """
    
        pass
    
    
    def getAliasList(*args, **kwargs):
        """
        Returns all of the node's attribute aliases.
        """
    
        pass
    
    
    def getConnections(*args, **kwargs):
        """
        Returns all the plugs which are connected to attributes of this node.
        """
    
        pass
    
    
    def hasAttribute(*args, **kwargs):
        """
        Returns True if the node has an attribute with the given name.
        """
    
        pass
    
    
    def hasUniqueName(*args, **kwargs):
        """
        Returns True if the node's name is unique.
        """
    
        pass
    
    
    def isFlagSet(*args, **kwargs):
        """
        Returns the state of the specified node flag.
        """
    
        pass
    
    
    def isNewAttribute(*args, **kwargs):
        """
        Returns True if the specified attribute was added in the current scene, and not by by one of its referenced files.
        """
    
        pass
    
    
    def name(*args, **kwargs):
        """
        Returns the node's name.
        """
    
        pass
    
    
    def plugsAlias(*args, **kwargs):
        """
        Returns the alias for a plug's attribute.
        """
    
        pass
    
    
    def removeAttribute(*args, **kwargs):
        """
        Removes a dynamic attribute from the node.
        """
    
        pass
    
    
    def reorderedAttribute(*args, **kwargs):
        """
        Returns one of the node's attribute, based on the order in which they are written to file.
        """
    
        pass
    
    
    def setAlias(*args, **kwargs):
        """
        Adds or removes an attribute alias.
        """
    
        pass
    
    
    def setDoNotWrite(*args, **kwargs):
        """
        Used to prevent the node from being written to file.
        """
    
        pass
    
    
    def setFlag(*args, **kwargs):
        """
        Sets the state of the specified node flag.
        """
    
        pass
    
    
    def setName(*args, **kwargs):
        """
        Sets the node's name.
        """
    
        pass
    
    
    def userNode(*args, **kwargs):
        """
        Returns the MPxNode object for a plugin node.
        """
    
        pass
    
    
    def allocateFlag(*args, **kwargs):
        """
        Allocates a flag on all nodes for use by the named plugin and returns the flag's index.
        """
    
        pass
    
    
    def classification(*args, **kwargs):
        """
        Returns the classification string for the named node type.
        """
    
        pass
    
    
    def deallocateAllFlags(*args, **kwargs):
        """
        Deallocates all node flags which are currently allocated to the named plugin.
        """
    
        pass
    
    
    def deallocateFlag(*args, **kwargs):
        """
        Deallocates the specified node flag, which was previously allocated by the named plugin using allocateFlag().
        """
    
        pass
    
    
    isDefaultNode = None
    
    isFromReferencedFile = None
    
    isLocked = None
    
    isShared = None
    
    namespace = None
    
    pluginName = None
    
    typeId = None
    
    typeName = None
    
    __new__ = None
    
    
    kExtensionAttr = None
    
    
    kInvalidAttr = None
    
    
    kLocalDynamicAttr = None
    
    
    kNormalAttr = None
    
    
    kTimerInvalidState = None
    
    
    kTimerMetric_callback = None
    
    
    kTimerMetric_callbackNotViaAPI = None
    
    
    kTimerMetric_callbackViaAPI = None
    
    
    kTimerMetric_compute = None
    
    
    kTimerMetric_computeDuringCallback = None
    
    
    kTimerMetric_computeNotDuringCallback = None
    
    
    kTimerMetric_dirty = None
    
    
    kTimerMetric_draw = None
    
    
    kTimerMetric_fetch = None
    
    
    kTimerOff = None
    
    
    kTimerOn = None
    
    
    kTimerType_count = None
    
    
    kTimerType_inclusive = None
    
    
    kTimerType_self = None
    
    
    kTimerUninitialized = None


class MFnData(MFnBase):
    """
    Base class for dependency graph data function sets.
    """
    
    
    
    def __init__(*args, **kwargs):
        """
        x.__init__(...) initializes x; see x.__class__.__doc__ for signature
        """
    
        pass
    
    
    __new__ = None
    
    
    kAny = None
    
    
    kComponentList = None
    
    
    kDoubleArray = None
    
    
    kDynArrayAttrs = None
    
    
    kDynSweptGeometry = None
    
    
    kIntArray = None
    
    
    kInvalid = None
    
    
    kLast = None
    
    
    kLattice = None
    
    
    kMatrix = None
    
    
    kMesh = None
    
    
    kNId = None
    
    
    kNObject = None
    
    
    kNumeric = None
    
    
    kNurbsCurve = None
    
    
    kNurbsSurface = None
    
    
    kPlugin = None
    
    
    kPluginGeometry = None
    
    
    kPointArray = None
    
    
    kSphere = None
    
    
    kString = None
    
    
    kStringArray = None
    
    
    kSubdSurface = None
    
    
    kVectorArray = None


class MFnLightDataAttribute(MFnAttribute):
    """
    Functionset for creating and working with light data attributes.
    """
    
    
    
    def __init__(*args, **kwargs):
        """
        x.__init__(...) initializes x; see x.__class__.__doc__ for signature
        """
    
        pass
    
    
    def child(*args, **kwargs):
        """
        Returns one of the attribute's children, specified by index.
        """
    
        pass
    
    
    def create(*args, **kwargs):
        """
        Creates a new light data attribute, attaches it to the function set and returns it as an MObject.
        """
    
        pass
    
    
    default = None
    
    __new__ = None


class MFnDoubleArrayData(MFnData):
    """
    Function set for node data consisting of an array of doubles.
    """
    
    
    
    def __delitem__(*args, **kwargs):
        """
        x.__delitem__(y) <==> del x[y]
        """
    
        pass
    
    
    def __getitem__(*args, **kwargs):
        """
        x.__getitem__(y) <==> x[y]
        """
    
        pass
    
    
    def __init__(*args, **kwargs):
        """
        x.__init__(...) initializes x; see x.__class__.__doc__ for signature
        """
    
        pass
    
    
    def __len__(*args, **kwargs):
        """
        x.__len__() <==> len(x)
        """
    
        pass
    
    
    def __setitem__(*args, **kwargs):
        """
        x.__setitem__(i, y) <==> x[i]=y
        """
    
        pass
    
    
    def array(*args, **kwargs):
        """
        Returns the encapsulated array as an MDoubleArray.
        """
    
        pass
    
    
    def copyTo(*args, **kwargs):
        """
        Replaces the elements of an array with those in the encapsulated array.
        """
    
        pass
    
    
    def create(*args, **kwargs):
        """
        Creates a new double array data object.
        """
    
        pass
    
    
    def set(*args, **kwargs):
        """
        Sets values in the encapsulated array.
        """
    
        pass
    
    
    __new__ = None


class MFnTypedAttribute(MFnAttribute):
    """
    Functionset for creating and working typed attributes.
    """
    
    
    
    def __init__(*args, **kwargs):
        """
        x.__init__(...) initializes x; see x.__class__.__doc__ for signature
        """
    
        pass
    
    
    def attrType(*args, **kwargs):
        """
        Returns the type of data handled by the attribute.
        """
    
        pass
    
    
    def create(*args, **kwargs):
        """
        Creates a new type attribute, attaches it to the function set and returns it as an MObject.
        """
    
        pass
    
    
    default = None
    
    __new__ = None


class MFnEnumAttribute(MFnAttribute):
    """
    Functionset for creating and working with enumeration attributes.
    """
    
    
    
    def __init__(*args, **kwargs):
        """
        x.__init__(...) initializes x; see x.__class__.__doc__ for signature
        """
    
        pass
    
    
    def addField(*args, **kwargs):
        """
        Add an item to the enumeration with a specified UI name and corresponding attribute value.
        """
    
        pass
    
    
    def create(*args, **kwargs):
        """
        Creates a new enumeration attribute, attaches it to the function set and returns it as an MObject.
        """
    
        pass
    
    
    def fieldName(*args, **kwargs):
        """
        Returns the name of the enumeration item which has a given value.
        """
    
        pass
    
    
    def fieldValue(*args, **kwargs):
        """
        Returns the value of the enumeration item which has a given name.
        """
    
        pass
    
    
    def getMax(*args, **kwargs):
        """
        Returns the maximum value of all the enumeration items.
        """
    
        pass
    
    
    def getMin(*args, **kwargs):
        """
        Returns the minimum value of all the enumeration items.
        """
    
        pass
    
    
    def setDefaultByName(*args, **kwargs):
        """
        Set the default value using the name of an enumeration item. Equivalent to: attr.default = attr.fieldValue(name)
        """
    
        pass
    
    
    default = None
    
    __new__ = None


class MFnUInt64ArrayData(MFnData):
    """
    Function set for node data consisting of an array of MUint64.
    """
    
    
    
    def __delitem__(*args, **kwargs):
        """
        x.__delitem__(y) <==> del x[y]
        """
    
        pass
    
    
    def __getitem__(*args, **kwargs):
        """
        x.__getitem__(y) <==> x[y]
        """
    
        pass
    
    
    def __init__(*args, **kwargs):
        """
        x.__init__(...) initializes x; see x.__class__.__doc__ for signature
        """
    
        pass
    
    
    def __len__(*args, **kwargs):
        """
        x.__len__() <==> len(x)
        """
    
        pass
    
    
    def __setitem__(*args, **kwargs):
        """
        x.__setitem__(i, y) <==> x[i]=y
        """
    
        pass
    
    
    def array(*args, **kwargs):
        """
        Returns the encapsulated array as an MUint64Array.
        """
    
        pass
    
    
    def copyTo(*args, **kwargs):
        """
        Replaces the elements of an array with those in the encapsulated array.
        """
    
        pass
    
    
    def create(*args, **kwargs):
        """
        Creates a new MUint64 array data object.
        """
    
        pass
    
    
    def set(*args, **kwargs):
        """
        Sets values in the encapsulated array.
        """
    
        pass
    
    
    __new__ = None


class MFnPointArrayData(MFnData):
    """
    Function set for node data consisting of an array of MPoints.
    """
    
    
    
    def __delitem__(*args, **kwargs):
        """
        x.__delitem__(y) <==> del x[y]
        """
    
        pass
    
    
    def __getitem__(*args, **kwargs):
        """
        x.__getitem__(y) <==> x[y]
        """
    
        pass
    
    
    def __init__(*args, **kwargs):
        """
        x.__init__(...) initializes x; see x.__class__.__doc__ for signature
        """
    
        pass
    
    
    def __len__(*args, **kwargs):
        """
        x.__len__() <==> len(x)
        """
    
        pass
    
    
    def __setitem__(*args, **kwargs):
        """
        x.__setitem__(i, y) <==> x[i]=y
        """
    
        pass
    
    
    def array(*args, **kwargs):
        """
        Returns the encapsulated array as an MPointArray.
        """
    
        pass
    
    
    def copyTo(*args, **kwargs):
        """
        Replaces the elements of an array with those in the encapsulated array.
        """
    
        pass
    
    
    def create(*args, **kwargs):
        """
        Creates a new MPoint array data object.
        """
    
        pass
    
    
    def set(*args, **kwargs):
        """
        Sets values in the encapsulated array.
        """
    
        pass
    
    
    __new__ = None


class MFnVectorArrayData(MFnData):
    """
    Function set for node data consisting of an array of MVectors.
    """
    
    
    
    def __delitem__(*args, **kwargs):
        """
        x.__delitem__(y) <==> del x[y]
        """
    
        pass
    
    
    def __getitem__(*args, **kwargs):
        """
        x.__getitem__(y) <==> x[y]
        """
    
        pass
    
    
    def __init__(*args, **kwargs):
        """
        x.__init__(...) initializes x; see x.__class__.__doc__ for signature
        """
    
        pass
    
    
    def __len__(*args, **kwargs):
        """
        x.__len__() <==> len(x)
        """
    
        pass
    
    
    def __setitem__(*args, **kwargs):
        """
        x.__setitem__(i, y) <==> x[i]=y
        """
    
        pass
    
    
    def array(*args, **kwargs):
        """
        Returns the encapsulated array as an MVectorArray.
        """
    
        pass
    
    
    def copyTo(*args, **kwargs):
        """
        Replaces the elements of an array with those in the encapsulated array.
        """
    
        pass
    
    
    def create(*args, **kwargs):
        """
        Creates a new MVector array data object.
        """
    
        pass
    
    
    def set(*args, **kwargs):
        """
        Sets values in the encapsulated array.
        """
    
        pass
    
    
    __new__ = None


class MFnStringArrayData(MFnData):
    """
    Function set for node data consisting of an array of string.
    """
    
    
    
    def __delitem__(*args, **kwargs):
        """
        x.__delitem__(y) <==> del x[y]
        """
    
        pass
    
    
    def __getitem__(*args, **kwargs):
        """
        x.__getitem__(y) <==> x[y]
        """
    
        pass
    
    
    def __init__(*args, **kwargs):
        """
        x.__init__(...) initializes x; see x.__class__.__doc__ for signature
        """
    
        pass
    
    
    def __len__(*args, **kwargs):
        """
        x.__len__() <==> len(x)
        """
    
        pass
    
    
    def __setitem__(*args, **kwargs):
        """
        x.__setitem__(i, y) <==> x[i]=y
        """
    
        pass
    
    
    def array(*args, **kwargs):
        """
        Returns the encapsulated array as a list of unicode objects.
        """
    
        pass
    
    
    def create(*args, **kwargs):
        """
        Creates a new string array data object.
        """
    
        pass
    
    
    def set(*args, **kwargs):
        """
        Sets values in the encapsulated array.
        """
    
        pass
    
    
    __new__ = None


class MFnMatrixData(MFnData):
    """
    Function set for matrix node data.
    """
    
    
    
    def __init__(*args, **kwargs):
        """
        x.__init__(...) initializes x; see x.__class__.__doc__ for signature
        """
    
        pass
    
    
    def create(*args, **kwargs):
        """
        Creates a new matrix data object.
        """
    
        pass
    
    
    def isTransformation(*args, **kwargs):
        """
        Returns True if the attached object is an MTransformationMatrix, False if it is an MMatrix.
        """
    
        pass
    
    
    def matrix(*args, **kwargs):
        """
        Returns the encapsulated matrix as an MMatrix.
        """
    
        pass
    
    
    def set(*args, **kwargs):
        """
        Sets the value of the encapsulated matrix.
        """
    
        pass
    
    
    def transformation(*args, **kwargs):
        """
        Returns the encapsulated matrix as an MTransformationMatrix.
        """
    
        pass
    
    
    __new__ = None


class MFnMatrixAttribute(MFnAttribute):
    """
    Functionset for creating and working with matrix attributes.
    """
    
    
    
    def __init__(*args, **kwargs):
        """
        x.__init__(...) initializes x; see x.__class__.__doc__ for signature
        """
    
        pass
    
    
    def create(*args, **kwargs):
        """
        Creates a new matrix attribute, attaches it to the function set and returns it as an MObject.
        """
    
        pass
    
    
    default = None
    
    __new__ = None
    
    
    kDouble = None
    
    
    kFloat = None


class MFnDagNode(MFnDependencyNode):
    """
    Function set for operating on DAG nodes.
    """
    
    
    
    def __init__(*args, **kwargs):
        """
        x.__init__(...) initializes x; see x.__class__.__doc__ for signature
        """
    
        pass
    
    
    def addChild(*args, **kwargs):
        """
        Makes a node a child of this one.
        """
    
        pass
    
    
    def child(*args, **kwargs):
        """
        Returns the specified child of this node.
        """
    
        pass
    
    
    def childCount(*args, **kwargs):
        """
        Returns the number of nodes which are children of this one.
        """
    
        pass
    
    
    def create(*args, **kwargs):
        """
        Creates a new DAG node and attaches it to the function set.
        """
    
        pass
    
    
    def dagPath(*args, **kwargs):
        """
        Returns the DAG path to which this function set is attached. Raises a TypeError if the function set is attached to an MObject rather than a path.
        """
    
        pass
    
    
    def dagRoot(*args, **kwargs):
        """
        Returns the root node of the first path leading to this node.
        """
    
        pass
    
    
    def duplicate(*args, **kwargs):
        """
        Duplicates the DAG hierarchy rooted at the current node.
        """
    
        pass
    
    
    def fullPathName(*args, **kwargs):
        """
        Returns the full path of the attached object, from the root of the DAG on down.
        """
    
        pass
    
    
    def getAllPaths(*args, **kwargs):
        """
        Returns all of the DAG paths which lead to the object to which this function set is attached.
        """
    
        pass
    
    
    def getPath(*args, **kwargs):
        """
        Returns the DAG path to which this function set is attached, or the first path to the node if the function set is attached to an MObject.
        """
    
        pass
    
    
    def hasChild(*args, **kwargs):
        """
        Returns True if the specified node is a child of this one.
        """
    
        pass
    
    
    def hasParent(*args, **kwargs):
        """
        Returns True if the specified node is a parent of this one.
        """
    
        pass
    
    
    def instanceCount(*args, **kwargs):
        """
        Returns the number of instances for this node.
        """
    
        pass
    
    
    def isChildOf(*args, **kwargs):
        """
        Returns True if the specified node is a parent of this one.
        """
    
        pass
    
    
    def isInstanced(*args, **kwargs):
        """
        Returns True if this node is instanced.
        """
    
        pass
    
    
    def isInstancedAttribute(*args, **kwargs):
        """
        Returns True if the specified attribute is an instanced attribute of this node.
        """
    
        pass
    
    
    def isParentOf(*args, **kwargs):
        """
        Returns True if the specified node is a child of this one.
        """
    
        pass
    
    
    def parent(*args, **kwargs):
        """
        Returns the specified parent of this node.
        """
    
        pass
    
    
    def parentCount(*args, **kwargs):
        """
        Returns the number of parents this node has.
        """
    
        pass
    
    
    def partialPathName(*args, **kwargs):
        """
        Returns the minimum path string necessary to uniquely identify the attached object.
        """
    
        pass
    
    
    def removeChild(*args, **kwargs):
        """
        Removes the child, specified by MObject, reparenting it under the world.
        """
    
        pass
    
    
    def removeChildAt(*args, **kwargs):
        """
        Removes the child, specified by index, reparenting it under the world.
        """
    
        pass
    
    
    def setObject(*args, **kwargs):
        """
        Attaches the function set to the specified node or DAG path.
        """
    
        pass
    
    
    def transformationMatrix(*args, **kwargs):
        """
        Returns the object space transformation matrix for this DAG node.
        """
    
        pass
    
    
    boundingBox = None
    
    inModel = None
    
    inUnderWorld = None
    
    isInstanceable = None
    
    isIntermediateObject = None
    
    objectColor = None
    
    useObjectColor = None
    
    __new__ = None
    
    
    kNextPos = None


class MFnNumericData(MFnData):
    """
    Function set for non-simple numeric node data.
    """
    
    
    
    def __init__(*args, **kwargs):
        """
        x.__init__(...) initializes x; see x.__class__.__doc__ for signature
        """
    
        pass
    
    
    def create(*args, **kwargs):
        """
        Creates a new numeric data object.
        """
    
        pass
    
    
    def getData(*args, **kwargs):
        """
        Returns a list containing the attached data object's data.
        """
    
        pass
    
    
    def numericType(*args, **kwargs):
        """
        Returns the type of data in the attached data object.
        """
    
        pass
    
    
    def setData(*args, **kwargs):
        """
        Sets the value of the data in the attached data object.
        """
    
        pass
    
    
    __new__ = None
    
    
    k2Double = None
    
    
    k2Float = None
    
    
    k2Int = None
    
    
    k2Long = None
    
    
    k2Short = None
    
    
    k3Double = None
    
    
    k3Float = None
    
    
    k3Int = None
    
    
    k3Long = None
    
    
    k3Short = None
    
    
    k4Double = None
    
    
    kAddr = None
    
    
    kBoolean = None
    
    
    kByte = None
    
    
    kChar = None
    
    
    kDouble = None
    
    
    kFloat = None
    
    
    kInt = None
    
    
    kInvalid = None
    
    
    kLast = None
    
    
    kLong = None
    
    
    kShort = None


class MFnStringData(MFnData):
    """
    Function set for string node data.
    """
    
    
    
    def __init__(*args, **kwargs):
        """
        x.__init__(...) initializes x; see x.__class__.__doc__ for signature
        """
    
        pass
    
    
    def create(*args, **kwargs):
        """
        Creates a new string data object.
        """
    
        pass
    
    
    def set(*args, **kwargs):
        """
        Sets the value of the encapsulated string.
        """
    
        pass
    
    
    def string(*args, **kwargs):
        """
        Returns the encapsulated string as a unicode object.
        """
    
        pass
    
    
    __new__ = None


class MFnMessageAttribute(MFnAttribute):
    """
    Functionset for creating and working with message attributes.
    """
    
    
    
    def __init__(*args, **kwargs):
        """
        x.__init__(...) initializes x; see x.__class__.__doc__ for signature
        """
    
        pass
    
    
    def create(*args, **kwargs):
        """
        Creates a new message attribute, attaches it to the function set and returns it as an MObject.
        """
    
        pass
    
    
    __new__ = None


class MFnGenericAttribute(MFnAttribute):
    """
    Functionset for creating and working with attributes which can accept several different types of data.
    """
    
    
    
    def __init__(*args, **kwargs):
        """
        x.__init__(...) initializes x; see x.__class__.__doc__ for signature
        """
    
        pass
    
    
    def addDataType(*args, **kwargs):
        """
        Adds the specified Maya data type to the list of those accepted by the attribute.
        """
    
        pass
    
    
    def addNumericType(*args, **kwargs):
        """
        Adds the specified numeric type to the list of those accepted by the attribute.
        """
    
        pass
    
    
    def addTypeId(*args, **kwargs):
        """
        Adds the specified data typeId to the list of those accepted by the attribute.
        """
    
        pass
    
    
    def create(*args, **kwargs):
        """
        Creates a new generic attribute, attaches it to the function set and returns it as an MObject.
        """
    
        pass
    
    
    def removeDataType(*args, **kwargs):
        """
        Removes the specified Maya data type from the list of those accepted by the attribute.
        """
    
        pass
    
    
    def removeNumericType(*args, **kwargs):
        """
        Removes the specified numeric type from the list of those accepted by the attribute.
        """
    
        pass
    
    
    def removeTypeId(*args, **kwargs):
        """
        Removes the specified data typeId from the list of those accepted by the attribute.
        """
    
        pass
    
    
    __new__ = None


class MFnIntArrayData(MFnData):
    """
    Function set for node data consisting of an array of ints.
    """
    
    
    
    def __delitem__(*args, **kwargs):
        """
        x.__delitem__(y) <==> del x[y]
        """
    
        pass
    
    
    def __getitem__(*args, **kwargs):
        """
        x.__getitem__(y) <==> x[y]
        """
    
        pass
    
    
    def __init__(*args, **kwargs):
        """
        x.__init__(...) initializes x; see x.__class__.__doc__ for signature
        """
    
        pass
    
    
    def __len__(*args, **kwargs):
        """
        x.__len__() <==> len(x)
        """
    
        pass
    
    
    def __setitem__(*args, **kwargs):
        """
        x.__setitem__(i, y) <==> x[i]=y
        """
    
        pass
    
    
    def array(*args, **kwargs):
        """
        Returns the encapsulated array as an MIntArray.
        """
    
        pass
    
    
    def copyTo(*args, **kwargs):
        """
        Replaces the elements of an array with those in the encapsulated array.
        """
    
        pass
    
    
    def create(*args, **kwargs):
        """
        Creates a new int array data object.
        """
    
        pass
    
    
    def set(*args, **kwargs):
        """
        Sets values in the encapsulated array.
        """
    
        pass
    
    
    __new__ = None


class MFnUnitAttribute(MFnAttribute):
    """
    Functionset for creating and working with angle, distance and time attributes.
    """
    
    
    
    def __init__(*args, **kwargs):
        """
        x.__init__(...) initializes x; see x.__class__.__doc__ for signature
        """
    
        pass
    
    
    def create(*args, **kwargs):
        """
        Creates a new unit attribute, attaches it to the function set and returns it as an MObject.
        """
    
        pass
    
    
    def getMax(*args, **kwargs):
        """
        Returns the attribute's hard maximum value.
        """
    
        pass
    
    
    def getMin(*args, **kwargs):
        """
        Returns the attribute's hard minimum value.
        """
    
        pass
    
    
    def getSoftMax(*args, **kwargs):
        """
        Returns the attribute's soft maximum value.
        """
    
        pass
    
    
    def getSoftMin(*args, **kwargs):
        """
        Returns the attribute's soft minimum value.
        """
    
        pass
    
    
    def hasMax(*args, **kwargs):
        """
        Returns True if the attribute has a hard maximum value.
        """
    
        pass
    
    
    def hasMin(*args, **kwargs):
        """
        Returns True if the attribute has a hard minimum value.
        """
    
        pass
    
    
    def hasSoftMax(*args, **kwargs):
        """
        Returns True if the attribute has a soft maximum value.
        """
    
        pass
    
    
    def hasSoftMin(*args, **kwargs):
        """
        Returns True if the attribute has a soft minimum value.
        """
    
        pass
    
    
    def setMax(*args, **kwargs):
        """
        Sets the attribute's hard maximum value.
        """
    
        pass
    
    
    def setMin(*args, **kwargs):
        """
        Sets the attribute's hard minimum value.
        """
    
        pass
    
    
    def setSoftMax(*args, **kwargs):
        """
        Sets the attribute's soft maximum value.
        """
    
        pass
    
    
    def setSoftMin(*args, **kwargs):
        """
        Sets the attribute's soft minimum value.
        """
    
        pass
    
    
    def unitType(*args, **kwargs):
        """
        Returns the type of data handled by the attribute.
        """
    
        pass
    
    
    default = None
    
    __new__ = None
    
    
    kAngle = None
    
    
    kDistance = None
    
    
    kInvalid = None
    
    
    kLast = None
    
    
    kTime = None


class MFnNumericAttribute(MFnAttribute):
    """
    Functionset for creating and working with numeric attributes.
    """
    
    
    
    def __init__(*args, **kwargs):
        """
        x.__init__(...) initializes x; see x.__class__.__doc__ for signature
        """
    
        pass
    
    
    def child(*args, **kwargs):
        """
        Returns the specified child attribute of the parent attribute currently attached to the function set.
        """
    
        pass
    
    
    def create(*args, **kwargs):
        """
        Creates a new simple or compound numeric attribute, attaches it to the function set and returns it in an MObject.
        """
    
        pass
    
    
    def createAddr(*args, **kwargs):
        """
        Creates a new address attribute, attaches it to the function set and returns it in an MObject.
        """
    
        pass
    
    
    def createColor(*args, **kwargs):
        """
        Creates a new color attribute, attaches it to the function set and returns it in an MObject.
        """
    
        pass
    
    
    def createPoint(*args, **kwargs):
        """
        Creates a new 3D point attribute, attaches it to the function set and returns it in an MObject.
        """
    
        pass
    
    
    def getMax(*args, **kwargs):
        """
        Returns the attribute's hard maximum value(s).
        """
    
        pass
    
    
    def getMin(*args, **kwargs):
        """
        Returns the attribute's hard minimum value(s).
        """
    
        pass
    
    
    def getSoftMax(*args, **kwargs):
        """
        Returns the attribute's soft maximum value.
        """
    
        pass
    
    
    def getSoftMin(*args, **kwargs):
        """
        Returns the attribute's soft minimum value.
        """
    
        pass
    
    
    def hasMax(*args, **kwargs):
        """
        Returns True if a hard maximum value has been specified for the attribute.
        """
    
        pass
    
    
    def hasMin(*args, **kwargs):
        """
        Returns True if a hard minimum value has been specified for the attribute.
        """
    
        pass
    
    
    def hasSoftMax(*args, **kwargs):
        """
        Returns True if a soft maximum value has been specified for the attribute.
        """
    
        pass
    
    
    def hasSoftMin(*args, **kwargs):
        """
        Returns True if a soft minimum value has been specified for the attribute.
        """
    
        pass
    
    
    def numericType(*args, **kwargs):
        """
        Returns the numeric type of the attribute currently attached to the function set.
        """
    
        pass
    
    
    def setMax(*args, **kwargs):
        """
        Sets the attribute's hard maximum value(s).
        """
    
        pass
    
    
    def setMin(*args, **kwargs):
        """
        Sets the attribute's hard minimum value(s).
        """
    
        pass
    
    
    def setSoftMax(*args, **kwargs):
        """
        Sets the attribute's soft maximum value.
        """
    
        pass
    
    
    def setSoftMin(*args, **kwargs):
        """
        Sets the attribute's soft minimum value.
        """
    
        pass
    
    
    default = None
    
    __new__ = None


class MFnCompoundAttribute(MFnAttribute):
    """
    Functionset for creating and working with compound attributes.
    """
    
    
    
    def __init__(*args, **kwargs):
        """
        x.__init__(...) initializes x; see x.__class__.__doc__ for signature
        """
    
        pass
    
    
    def addChild(*args, **kwargs):
        """
        Add a child attribute.
        """
    
        pass
    
    
    def child(*args, **kwargs):
        """
        Returns one of the attribute's children, specified by index.
        """
    
        pass
    
    
    def create(*args, **kwargs):
        """
        Creates a new compound attribute, attaches it to the function set and returns it as an MObject.
        """
    
        pass
    
    
    def getAddAttrCmds(*args, **kwargs):
        """
        Returns a list of MEL 'addAttr' commands capable of recreating the attribute and all of its children.
        """
    
        pass
    
    
    def numChildren(*args, **kwargs):
        """
        Returns number of child attributes currently parented under the compound attribute.
        """
    
        pass
    
    
    def removeChild(*args, **kwargs):
        """
        Remove a child attribute.
        """
    
        pass
    
    
    __new__ = None


class MFnTransform(MFnDagNode):
    """
    Function set for operating on transform nodes.
    """
    
    
    
    def __init__(*args, **kwargs):
        """
        x.__init__(...) initializes x; see x.__class__.__doc__ for signature
        """
    
        pass
    
    
    def clearRestPosition(*args, **kwargs):
        """
        Clears the transform's rest position matrix.
        """
    
        pass
    
    
    def create(*args, **kwargs):
        """
        Creates a new transform node and attaches it to the function set.
        """
    
        pass
    
    
    def enableLimit(*args, **kwargs):
        """
        Enables or disables a specified limit type.
        """
    
        pass
    
    
    def isLimited(*args, **kwargs):
        """
        Returns True if the specified limit type is enabled.
        """
    
        pass
    
    
    def limitValue(*args, **kwargs):
        """
        Returns the value of the specified limit.
        """
    
        pass
    
    
    def resetFromRestPosition(*args, **kwargs):
        """
        Resets the transform from its rest position matrix.
        """
    
        pass
    
    
    def restPosition(*args, **kwargs):
        """
        Returns the transform's rest position matrix.
        """
    
        pass
    
    
    def rotateBy(*args, **kwargs):
        """
        Adds an MEulerRotation or MQuaternion to the transform's rotation.
        """
    
        pass
    
    
    def rotateByComponents(*args, **kwargs):
        """
        Adds to the transform's rotation using the individual components of an MEulerRotation or MQuaternion.
        """
    
        pass
    
    
    def rotateOrientation(*args, **kwargs):
        """
        Returns the MQuaternion which orients the local rotation space.
        """
    
        pass
    
    
    def rotatePivot(*args, **kwargs):
        """
        Returns the transform's rotate pivot.
        """
    
        pass
    
    
    def rotatePivotTranslation(*args, **kwargs):
        """
        Returns the transform's rotate pivot translation.
        """
    
        pass
    
    
    def rotation(*args, **kwargs):
        """
        Returns the transform's rotation as an MEulerRotation or MQuaternion.
        """
    
        pass
    
    
    def rotationComponents(*args, **kwargs):
        """
        Returns the transform's rotation as the individual components of an MEulerRotation or MQuaternion.
        """
    
        pass
    
    
    def rotationOrder(*args, **kwargs):
        """
        Returns the order of rotations when the transform's rotation is expressed as an MEulerRotation.
        """
    
        pass
    
    
    def scale(*args, **kwargs):
        """
        Returns a list containing the transform's XYZ scale components.
        """
    
        pass
    
    
    def scaleBy(*args, **kwargs):
        """
        Multiplies the transform's XYZ scale components by a sequence of three floats.
        """
    
        pass
    
    
    def scalePivot(*args, **kwargs):
        """
        Returns the transform's scale pivot.
        """
    
        pass
    
    
    def scalePivotTranslation(*args, **kwargs):
        """
        Returns the transform's scale pivot translation.
        """
    
        pass
    
    
    def setLimit(*args, **kwargs):
        """
        Sets the value of the specified limit.
        """
    
        pass
    
    
    def setRestPosition(*args, **kwargs):
        """
        Sets the transform's rest position matrix.
        """
    
        pass
    
    
    def setRotateOrientation(*args, **kwargs):
        """
        Sets the MQuaternion which orients the local rotation space.
        """
    
        pass
    
    
    def setRotatePivot(*args, **kwargs):
        """
        Sets the transform's rotate pivot.
        """
    
        pass
    
    
    def setRotatePivotTranslation(*args, **kwargs):
        """
        Sets the transform's rotate pivot translation.
        """
    
        pass
    
    
    def setRotation(*args, **kwargs):
        """
        Sets the transform's rotation using an MEulerRotation or MQuaternion.
        """
    
        pass
    
    
    def setRotationComponents(*args, **kwargs):
        """
        Sets the transform's rotation using the individual components of an MEulerRotation or MQuaternion.
        """
    
        pass
    
    
    def setRotationOrder(*args, **kwargs):
        """
        Sets the transform's rotation order.
        """
    
        pass
    
    
    def setScale(*args, **kwargs):
        """
        Sets the transform's scale components.
        """
    
        pass
    
    
    def setScalePivot(*args, **kwargs):
        """
        Sets the transform's scale pivot.
        """
    
        pass
    
    
    def setScalePivotTranslation(*args, **kwargs):
        """
        Sets the transform's scale pivot translation.
        """
    
        pass
    
    
    def setShear(*args, **kwargs):
        """
        Sets the transform's shear.
        """
    
        pass
    
    
    def setTransformation(*args, **kwargs):
        """
        Sets the transform's attribute values to represent the given transformation matrix.
        """
    
        pass
    
    
    def setTranslation(*args, **kwargs):
        """
        Sets the transform's translation.
        """
    
        pass
    
    
    def shear(*args, **kwargs):
        """
        Returns a list containing the transform's shear components.
        """
    
        pass
    
    
    def shearBy(*args, **kwargs):
        """
        Multiplies the transform's shear components by a sequence of three floats.
        """
    
        pass
    
    
    def transformation(*args, **kwargs):
        """
        Returns the transformation matrix represented by this transform.
        """
    
        pass
    
    
    def translateBy(*args, **kwargs):
        """
        Adds an MVector to the transform's translation.
        """
    
        pass
    
    
    def translation(*args, **kwargs):
        """
        Returns the transform's translation as an MVector.
        """
    
        pass
    
    
    __new__ = None
    
    
    kRotateMaxX = None
    
    
    kRotateMaxY = None
    
    
    kRotateMaxZ = None
    
    
    kRotateMinX = None
    
    
    kRotateMinY = None
    
    
    kRotateMinZ = None
    
    
    kScaleMaxX = None
    
    
    kScaleMaxY = None
    
    
    kScaleMaxZ = None
    
    
    kScaleMinX = None
    
    
    kScaleMinY = None
    
    
    kScaleMinZ = None
    
    
    kShearMaxXY = None
    
    
    kShearMaxXZ = None
    
    
    kShearMaxYZ = None
    
    
    kShearMinXY = None
    
    
    kShearMinXZ = None
    
    
    kShearMinYZ = None
    
    
    kTranslateMaxX = None
    
    
    kTranslateMaxY = None
    
    
    kTranslateMaxZ = None
    
    
    kTranslateMinX = None
    
    
    kTranslateMinY = None
    
    
    kTranslateMinZ = None