
'''
Stub class file for:
OpenMaya

Maya2009 Python API stub file
Generated from original Maya documentation.
Autodesk Maya 2009  c1997-2008 Autodesk, Inc. All rights reserved. 
'''




class MaterialInputData:
    '''Phong shading parameters for an MPxMaterialInformation instance. The MaterialInputData class is used to specify the phong shading parameters to be used with an MPxMaterialInformation instance. '''
    def __init__(self):
        pass


class MAngle:
    '''Manipulate Angular Data. Methods for setting and retreiving angular data in various unit systemsThe MAngle class provides a fundamental type for the Maya API to hold and manipulate angular data. All API methods that require or return angular information do so through variables of this type. '''
    def __init__(self):
        pass


    def setValue(self, newValue): 
        '''setValue(self, newValue)
Arguments:
	[in]	newValue = double


Set current value. 
'''
        pass

    def uiUnit(self): 
        '''uiUnit(self) -> MAngle.Unit


Working unit. 
'''
        pass

    def asAngMinutes(self): 
        '''asAngMinutes(self) -> double


Convert to minutes of arc. 
'''
        pass

    def asDegrees(self): 
        '''asDegrees(self) -> double


Convert to degrees. 
'''
        pass

    def value(self): 
        '''value(self) -> double


Current value. 
'''
        pass

    def as(self, otherUnit): 
        '''as(self, otherUnit) -> double
Returns: The current value in the given units

Arguments:
	[in]	otherUnit = MAngle.Unit


Unit conversion. 
'''
        pass

    def asRadians(self): 
        '''asRadians(self) -> double


Convert to radians. 
'''
        pass

    def kInvalid(self):
        '''This is an enum of Unit.
Description: Invalid value.
Value: 0'''
        pass

    def kAngMinutes(self):
        '''This is an enum of Unit.
Description: Minutes of Arc.
Value: 3'''
        pass

    def kLast(self):
        '''This is an enum of Unit.
Description: Last enum value.
Value: 5'''
        pass

    def kDegrees(self):
        '''This is an enum of Unit.
Description: Degrees.
Value: 2'''
        pass

    def kAngSeconds(self):
        '''This is an enum of Unit.
Description: Seconds of Arc.
Value: 4'''
        pass

    def kRadians(self):
        '''This is an enum of Unit.
Description: Radians.
Value: 1'''
        pass

    class Unit:
        '''Non-functional class.  Values for this enum:
        kInvalid
        kAngMinutes
        kLast
        kDegrees
        kAngSeconds
        kRadians
'''
        def __init__(self):
            pass

    def uiToInternal(self, uiValue): 
        '''uiToInternal(self, uiValue) -> double
Returns: The value in internal units. 

Arguments:
	[in]	uiValue = double


Unit conversion. 
'''
        pass

    def internalUnit(self): 
        '''internalUnit(self) -> MAngle.Unit


Internal unit. 
'''
        pass

    def internalToUI(self, internalValue): 
        '''internalToUI(self, internalValue) -> double
Returns: The value in UI units 

Arguments:
	[in]	internalValue = double


Unit conversion. 
'''
        pass

    def asAngSeconds(self): 
        '''asAngSeconds(self) -> double


Convert to seconds of arc. 
'''
        pass

    def setUnit(self, newUnit): 
        '''setUnit(self, newUnit)
Arguments:
	[in]	newUnit = MAngle.Unit


Set current unit. 
'''
        pass

    def unit(self): 
        '''unit(self) -> MAngle.Unit


Current unit. 
'''
        pass

    def setUIUnit(self, newUnit): 
        '''setUIUnit(self, newUnit)
Arguments:
	[in]	newUnit = MAngle.Unit


Set working unit. 
'''
        pass

class MArgDatabase:
    '''Command argument list parser. This class is used to parse and store all of the flags, arguments and objects which are passed to a command. The MArgDatabase accepts an MSyntax object, which describes the format for a command, and uses it to parse the command arguments into a form which is easy to query. The documentation for the MSyntax command contains the details on three types of arguments to commands:Once the syntax for your command has been specified, when the  method for the command it called, the provided MArgList instance can be passed to the MArgDatabase constructor along with the command's syntax object to parse those arguments. If the parsing is unsuccessful, then the provided command was syntactically invalid. If successful, the methods in this class can be used to extract the values of the arguments to the command.The  method can be used to find out if a particular flag argument was provided in the command invocation, and the  methods are used to return the value of that flag.If the command requires  (i.e. the  method was used to construct the syntax object), then  methods are used to return the values of those arguments.If the command requires  then the  methods are used to return those objects either as a selection list of as a list of strings.  and  are incompatible and must not be combined in the syntax definition of a command. If both have been specified to the Syntax object, then neither the  or  methods will work predictably. '''
    def __init__(self):
        pass


    def getCommandArgument(self, index, result): 
        '''getCommandArgument(self, index, result)
Arguments:
	[in]	index = int
	[out]	result = MSelectionList


Gets the value of the requested command argument to the command and appends it to the end of the  MSelectionList  that is passed in.'''
        pass

    def getObjects(self, result): 
        '''getObjects(self, result)
Arguments:
	[out]	result = MStringArray


Gets the list of objects passed to the command as an array of strings.'''
        pass

    def getFlagArgument(self, flag, index, result): 
        '''getFlagArgument(self, flag, index, result)
Arguments:
	[in]	flag = char
	[in]	index = int
	[out]	result = MSelectionList


Gets the value of the requested flag argument to the given flag as an  MSelectionList .'''
        pass

class MArgList:
    '''Create and retreive argument lists. This class is used to create and retrieve argument lists that can be passed to API class methods that require arglists. '''
    def __init__(self):
        pass


    def asMatrix(self, index): 
        '''asMatrix(self, index) -> MMatrix
Returns: The MMatrix value of the indicated argument.

Arguments:
	[out]	index = int


Get the value of the  MMatrix  argument at a given position in the arglist.'''
        pass

    def asIntArray(self, index): 
        '''asIntArray(self, index) -> MIntArray
Returns: MIntArray 

Arguments:
	[out]	index = int


Get the value of the  MIntArray  argument at a given position in the arglist.'''
        pass

    def asTime(self, index): 
        '''asTime(self, index) -> MTime
Returns: The MTime value of the indicated argument.

Arguments:
	[in]	index = int


Return the value of the argument at a given position in the arglist as an  MTime .'''
        pass

    def asBool(self, index): 
        '''asBool(self, index) -> bool
Returns: The bool value of the indicated argument.

Arguments:
	[in]	index = int


Return the value of the argument at a given position in the arglist as an bool.'''
        pass

    def asDoubleArray(self, index): 
        '''asDoubleArray(self, index) -> MDoubleArray
Returns: MDoubleArray 

Arguments:
	[out]	index = int


Get the value of the  MDoubleArray  argument at a given position in the arglist.'''
        pass

    def asVector(self, numElements, index): 
        '''asVector(self, numElements, index) -> MVector
Returns: The MVector value of the indicated argument.

Arguments:
	[out]	index = int
	[in]	numElements = int


Return the value of the argument at a given position in the arglist as an  MVector .'''
        pass

    def addArg(self, arg): 
        '''addArg(self, arg)
Arguments:
	[in]	arg = MPoint


Add a new  MPoint  argument to the arglist.'''
        pass

    def flagIndex(self, shortFlag, longFlag): 
        '''flagIndex(self, shortFlag, longFlag) -> int
Returns: The unsigned int index of the indicated argument if it has been set, kInvalidArgIndex otherwise. 

Arguments:
	[in]	shortFlag = char
	[in]	longFlag = char


Return the index entry of the requested flag, if it has been set.'''
        pass

    def length(self): 
        '''length(self) -> int
Returns: The number of arguments in the arglist.


Returns the number of arguments in the arglist.'''
        pass

    def asDistance(self, index): 
        '''asDistance(self, index) -> MDistance
Returns: The MDistance value of the indicated argument.

Arguments:
	[in]	index = int


Return the value of the argument at a given position in the arglist as an  MDistance .'''
        pass

    def asPoint(self, numElements, index): 
        '''asPoint(self, numElements, index) -> MPoint
Returns: The MPoint value of the indicated argument.

Arguments:
	[out]	index = int
	[in]	numElements = int


Return the value of the argument at a given position in the arglist as an  MPoint .'''
        pass

    def asAngle(self, index): 
        '''asAngle(self, index) -> MAngle
Returns: The MAngle value of the indicated argument.

Arguments:
	[in]	index = int


Return the value of the argument at a given position in the arglist as an  MAngle .'''
        pass

    def asDouble(self, index): 
        '''asDouble(self, index) -> double
Returns: The double value of the indicated argument.

Arguments:
	[in]	index = int


Return the value of the argument at a given position in the arglist as a double.'''
        pass

    def asString(self, index): 
        '''asString(self, index) -> MString
Returns: The MString value of the indicated argument.

Arguments:
	[in]	index = int


Return the value of the argument at a given position in the arglist as an  MString .'''
        pass

    def MStringArray(self, index): 
        '''MStringArray(self, index) -> const
Returns: MStringArray 

Arguments:
	[out]	index = int


Get the value of the  MStringArray  argument at a given position in the arglist.'''
        pass

    def asInt(self, index): 
        '''asInt(self, index) -> int
Returns: The integer value of the indicated argument.

Arguments:
	[in]	index = int


Return the value of the argument at a given position in the arglist as an integer.'''
        pass

class MArgParser:
    '''Command argument list parser. This class is used to parse and store all of the flags, arguments and objects which are passed to a command. The MArgParser accepts an MSyntax object, which describes the format for a command, and uses it to parse the command arguments into a form which is easy to query. The documentation for the MSyntax command contains the details on three types of arguments to commands:Once the syntax for your command has been specified, when the  method for the command it called, the provided MArgList instance can be passed to the MArgParser constructor along with the command's syntax object to parse those arguments. If the parsing is unsuccessful, then the provided command was syntactically invalid. If successful, the methods in this class can be used to extract the values of the arguments to the command.The  method can be used to find out if a particular flag argument was provided in the command invocation, and the  methods are used to return the value of that flag.If the command requires  (i.e. the  method was used to construct the syntax object), then  methods are used to return the values of those arguments.If the command requires  then the  methods are used to return those objects either as a selection list of as a list of strings.'''
    def __init__(self):
        pass


    def flagArgumentString(self, flag, index): 
        '''flagArgumentString(self, flag, index) -> MString

Arguments:
	[in]	flag = char
	[in]	index = int


Gets the value of the requested flag argument to the given flag as an  MString .'''
        pass

    def isQuery(self): 
        '''isQuery(self) -> bool
Returns: true if query flag is set 
false if query flag is not set


Determines if the query flag was one of the arguments to the command. The query flag in its short form is "-q", and in its int form is "-query".'''
        pass

    def commandArgumentMTime(self, index): 
        '''commandArgumentMTime(self, index) -> MTime

Arguments:
	[in]	index = int


Gets the value of the requested command argument as a  MTime .'''
        pass

    def getFlagArgumentList(self, flag, i, args): 
        '''getFlagArgumentList(self, flag, i, args)
Arguments:
	[in]	flag = char
	[in]	i = int
	[out]	args = MArgList


Returns an  MArgList  containing the arguments to the i'th usage of the specified flag. This call is only valid if the flags has been marked as available for multi-usage with  MSyntax::makeFlagMultiUse'''
        pass

    def commandArgumentMAngle(self, index): 
        '''commandArgumentMAngle(self, index) -> MAngle

Arguments:
	[in]	index = int


Gets the value of the requested command argument as a  MAngle .'''
        pass

    def flagArgumentDouble(self, flag, index): 
        '''flagArgumentDouble(self, flag, index) -> double

Arguments:
	[in]	flag = char
	[in]	index = int


Gets the value of the requested flag argument to the given flag as a double.'''
        pass

    def commandArgumentString(self, index): 
        '''commandArgumentString(self, index) -> MString

Arguments:
	[in]	index = int


Gets the value of the requested command argument as a string.'''
        pass

    def numberOfFlagsUsed(self): 
        '''numberOfFlagsUsed(self) -> int


Returns the number of flags given on the command line command line.'''
        pass

    def commandArgumentBool(self, index): 
        '''commandArgumentBool(self, index) -> bool

Arguments:
	[in]	index = int


Gets the value of the requested command argument as a boolean.'''
        pass

    def commandArgumentDouble(self, index): 
        '''commandArgumentDouble(self, index) -> double

Arguments:
	[in]	index = int


Gets the value of the requested command argument as a double.'''
        pass

    def getObjects(self, result): 
        '''getObjects(self, result)
Arguments:
	[out]	result = MStringArray


Gets the list of objects passed to the command as an array of strings.'''
        pass

    def flagArgumentMAngle(self, flag, index): 
        '''flagArgumentMAngle(self, flag, index) -> MAngle

Arguments:
	[in]	flag = char
	[in]	index = int


Gets the value of the requested flag argument to the given flag as an  MAngle .'''
        pass

    def numberOfFlagUses(self, flag): 
        '''numberOfFlagUses(self, flag) -> int
Returns: Number of times the given flag was used on the command line 

Arguments:
	[in]	flag = char


Returns the number of times the given flag was used on the command line.'''
        pass

    def isFlagSet(self, flag): 
        '''isFlagSet(self, flag) -> bool
Returns: true if given flag is set 
false if given flag is not set

Arguments:
	[in]	flag = char


Queries the arguments to the command to determine if the given flag is set.'''
        pass

    def getCommandArgument(self, index, result): 
        '''getCommandArgument(self, index, result)
Arguments:
	[in]	index = int
	[out]	result = MTime


Gets the value of the requested command argument to the command as an  MTime .'''
        pass

    def commandArgumentInt(self, index): 
        '''commandArgumentInt(self, index) -> int

Arguments:
	[in]	index = int


Gets the value of the requested command argument as an int.'''
        pass

    def commandArgumentMDistance(self, index): 
        '''commandArgumentMDistance(self, index) -> MDistance

Arguments:
	[in]	index = int


Gets the value of the requested command argument as a  MDistance .'''
        pass

    def isEdit(self): 
        '''isEdit(self) -> bool
Returns: true if edit flag is set 
false if edit flag is not set


Determines if the edit flag was one of the arguments to the command. The edit flag in its short form is "-e", and in its int form is "-edit".'''
        pass

    def getFlagArgument(self, flag, index, result): 
        '''getFlagArgument(self, flag, index, result)
Arguments:
	[in]	flag = char
	[in]	index = int
	[out]	result = MTime


Gets the value of the requested flag argument to the given flag as an  MTime .'''
        pass

    def getFlagArgumentPosition(self, flag, i, position): 
        '''getFlagArgumentPosition(self, flag, i, position)
Arguments:
	[in]	flag = char
	[in]	i = int
	[out]	position = int


Returns the position in the command line of the i'th usage of a specified flag. This call is only valid if the flags has been marked as available for multi-usage with  MSyntax::makeFlagMultiUse'''
        pass

    def flagArgumentMDistance(self, flag, index): 
        '''flagArgumentMDistance(self, flag, index) -> MDistance

Arguments:
	[in]	flag = char
	[in]	index = int


Gets the value of the requested flag argument to the given flag as an  MDistance .'''
        pass

    def flagArgumentInt(self, flag, index): 
        '''flagArgumentInt(self, flag, index) -> int

Arguments:
	[in]	flag = char
	[in]	index = int


Gets the value of the requested flag argument to the given flag as a int.'''
        pass

    def flagArgumentMTime(self, flag, index): 
        '''flagArgumentMTime(self, flag, index) -> MTime

Arguments:
	[in]	flag = char
	[in]	index = int


Gets the value of the requested flag argument to the given flag as an  MTime .'''
        pass

    def flagArgumentBool(self, flag, index): 
        '''flagArgumentBool(self, flag, index) -> bool

Arguments:
	[in]	flag = char
	[in]	index = int


Gets the value of the requested flag argument to the given flag as a boolean.'''
        pass

class MArrayDataBuilder:
    '''Array builder for arrays in data blocks. An MArrayDataBuilder is used to construct data for attributes/plugs that have an array of data. An array builder is used with an MArrayDataHandle for managing data. '''
    def __init__(self):
        pass


    def addElementArray(self, index): 
        '''addElementArray(self, index) -> MArrayDataHandle
Returns: The handle for the new array element

Arguments:
	[in]	index = int


Adds a new element to the array at the given index. The added element is also an array.'''
        pass

    def setGrowSize(self, size): 
        '''setGrowSize(self, size)
Arguments:
	[in]	size = int


Sets the grow size of the array. As elements are added to the array, the builder will allocate memory in chunks. This method tells the builder how many elements to allocate each time it grows the array.'''
        pass

    def addLast(self): 
        '''addLast(self) -> MDataHandle
Returns: The handle for the new element


Adds a new element to the end of the array. The index of the element will be the current highest index + 1.'''
        pass

    def addElement(self, index): 
        '''addElement(self, index) -> MDataHandle
Returns: The handle for the new element

Arguments:
	[in]	index = int


Adds a new element to the array at the given index.'''
        pass

    def elementCount(self): 
        '''elementCount(self) -> int
Returns: The number of elements


Returns the number of elements in the array'''
        pass

    def addLastArray(self): 
        '''addLastArray(self) -> MArrayDataHandle
Returns: The handle for the new array element


Adds a new element to the end of the array. The added element is also an array. The index of the element will the current highest index + 1.'''
        pass

    def growArray(self, amount): 
        '''growArray(self, amount)
Arguments:
	[in]	amount = int


Grows the array storage by the given amount.'''
        pass

    def removeElement(self, index): 
        '''removeElement(self, index)
Arguments:
	[in]	index = int


Removes the specified element from the array'''
        pass

class MArrayDataHandle:
    '''Data block handle for array data. An MArrayDataHandle is a smart pointer into a data block (MDataBlock) that handles access to array data. MArrayDataHandle supports attributes that can have an array of data.The array indices do not have to be continuous. The array can be sparse. Thus, an array could have four elements with the indicies 1, 6, 8, and 10.MArrayDataHandle methods cannot be assumed to be threadsafe. The jumpToElement() method sets an internal pointer so definitely cannot be called by multiple threads simultaneously. '''
    def __init__(self):
        pass


    def elementIndex(self): 
        '''elementIndex(self) -> int
Returns: The current element's logical index


Returns the index that we are currently at in the array. It is possible for the index to be invalid, in which case the return status will report an error. These may be sparse arrays so the element index returned will be a logical index.'''
        pass

    def jumpToElement(self, index): 
        '''jumpToElement(self, index)
Arguments:
	[in]	index = int


Jump to a specific element in the array. The array is sparse, so the indices may not be consecutive.'''
        pass

    def setAllClean(self): 
        '''setAllClean(self)

Marks every element of the array attribute represented by the handle as clean. This method should be used if a compute function is asked to compute a single element of a multi, but instead calculates all the elements. Calling  setAllClean  in this situation will prevent further calls to the node's compute method for the other elements of the multi.'''
        pass

    def outputArrayValue(self): 
        '''outputArrayValue(self) -> MArrayDataHandle
Returns: Data handle for the current element's data


Gets a handle into this data block for the current array element. This method should be used when the array elements are also arrays. The data is not guaranteed to be valid. Therefore, this handle should only be used for writing over the data.'''
        pass

    def builder(self): 
        '''builder(self) -> MArrayDataBuilder
Returns: The builder object


Returns a builder for this handle's array so that it can be expanded.'''
        pass

    def next(self): 
        '''next(self)

Advance to the next element in the array. These may be sparse arrays so the next consecutive element may not necessarily have a consecutive index.'''
        pass

    def outputValue(self): 
        '''outputValue(self) -> MDataHandle
Returns: Data handle for the current element's data


Gets a handle into this data block for the current array element. The data is not guaranteed to be valid. Therefore, this handle should only be used for writing over the data.'''
        pass

    def elementCount(self): 
        '''elementCount(self) -> int
Returns: The number of elements


Returns the number of elements in the array.'''
        pass

    def set(self, builder): 
        '''set(self, builder)
Arguments:
	[in]	builder = MArrayDataBuilder


Sets the data for this array from the data in the builder object'''
        pass

    def inputValue(self): 
        '''inputValue(self) -> MDataHandle
Returns: Data handle for the current element's data


Gets a handle into this data block for the current array element. The data represented by the handle will be valid. If the data is from an dirty connection, then the connection will be evaluated.'''
        pass

    def jumpToArrayElement(self, position): 
        '''jumpToArrayElement(self, position)
Arguments:
	[in]	position = int


Jump to a specific array element in the array. This method can be used to iterate over the entire array.'''
        pass

    def setClean(self): 
        '''setClean(self)

Marks the data that is represented by this handle as being clean. This should be done after recalculating the data from the inputs.'''
        pass

    def inputArrayValue(self): 
        '''inputArrayValue(self) -> MArrayDataHandle
Returns: Data handle for the current element's data


Gets a handle into this data block for the current array element. This method should be used when the array elements are also arrays. The data represented by the handle will be valid. If the data is from an dirty connection, then the connection will be evailuated.'''
        pass

class MAttributeIndex:
    '''The index information for an attribute specification. Class that provides access to the index part of an attribute specification (MAttributeSpec).See MAttributeSpec for more information. '''
    def __init__(self):
        pass


    def isBounded(self): 
        '''isBounded(self) -> bool


Returns true if this object is bounded.'''
        pass

    def setValue(self, value): 
        '''setValue(self, value)
Arguments:
	[in]	value = double


Sets the index value of this object.'''
        pass

    def __neq__(self, other): 
        '''__neq__(self, other) -> bool
Returns: Boolean indicating whether the objects are same. 

Arguments:
	[in]	other = MAttributeIndex


Inequality operator.'''
        pass

    def hasRange(self): 
        '''hasRange(self) -> bool


Return true if a range was specified.'''
        pass

    def getUpper(self, value): 
        '''getUpper(self, value)
Arguments:
	[out]	value = double


Return the upper bound for this object or false if 1) the type does not match the argument type or 2) there is no upper bound. (both of which can be tested for using other methods on this class).'''
        pass

    def setUpper(self, value): 
        '''setUpper(self, value)
Arguments:
	[in]	value = double


Sets the upper bounds of this object.'''
        pass

    def hasLowerBound(self): 
        '''hasLowerBound(self) -> bool


Return true if if there is a lower bound specified.'''
        pass

    def getValue(self, value): 
        '''getValue(self, value)
Arguments:
	[out]	value = double


Return the current value of the index or false if 1) the type does not match the argument type or 2) the index is a range or 3) the index is unbounded.'''
        pass

    def hasValidRange(self): 
        '''hasValidRange(self) -> bool


Return true if upper value is greater than lower value.'''
        pass

    def hasUpperBound(self): 
        '''hasUpperBound(self) -> bool


Return true if if there is an upper bound specified.'''
        pass

    def setLower(self, value): 
        '''setLower(self, value)
Arguments:
	[in]	value = double


Sets the lower bounds of this object.'''
        pass

    def __eq__(self, other): 
        '''__eq__(self, other) -> bool
Returns: Boolean indicating whether the objects are same. 

Arguments:
	[in]	other = MAttributeIndex


Equality operator.'''
        pass

    def getLower(self, value): 
        '''getLower(self, value)
Arguments:
	[out]	value = double


Return the lower bound for this object or false if 1) the type does not match the argument type or 2) there is no lower bound. (both of which can be tested for using other methods on this class).'''
        pass

    def type(self): 
        '''type(self) -> MAttributeIndex.MIndexType


Returns the type of attribute index.'''
        pass

    def kInteger(self):
        '''This is an enum of MIndexType.
Description: Integer index (e.g. mesh.cp[5]).
Value: 0'''
        pass

    def kFloat(self):
        '''This is an enum of MIndexType.
Description: Floating-poing index (e.g. curve.u[1.3]).
Value: 1'''
        pass

    class MIndexType:
        '''Non-functional class.  Values for this enum:
        kInteger
        kFloat
'''
        def __init__(self):
            pass

    def setType(self, type): 
        '''setType(self, type)
Arguments:
	[in]	type = MAttributeIndex.MIndexType


Sets the type of attribute index.'''
        pass

class MAttributeSpec:
    '''An attribute specification. Class that encapsulates component/attribute information for generating selection items.This class is used by MPxSurfaceShape::matchComponent for validating attributes specified as strings and converting that specification to a component object.The attribute specification ".foo.bar[3].x" would be expressed like this (using a pseudo-structure description):'''
    def __init__(self):
        pass


    def MString(self): 
        '''MString(self) -> const


Returns the attribute name part of the specification.'''
        pass

    def setDimensions(self, value): 
        '''setDimensions(self, value)
Arguments:
	[in]	value = int


Set the dimension of the attribute specification. Array attribute dimensions are > 0.'''
        pass

    def dimensions(self): 
        '''dimensions(self) -> int


Returns the dimension of the attribute specification. For array attributes the dimension is > 0.'''
        pass

    def setName(self, name): 
        '''setName(self, name)
Arguments:
	[in]	name = MString


Set the attribute name part of the specification.'''
        pass

    def __eq__(self, other): 
        '''__eq__(self, other) -> bool
Returns: The boolean indicating whether the object are same or not. 

Arguments:
	[in]	other = MAttributeSpec


Comparison operator.'''
        pass

    def MAttributeIndex(self, index): 
        '''MAttributeIndex(self, index) -> const
Returns: The MAttributeIndex associated with the given index. 

Arguments:
	[in]	index = int


Returns an attribute index object for the specified element.'''
        pass

class MAttributeSpecArray:
    '''An attribute specification array. Array class for MAttributeSpec.See MAttributeSpec for more information. '''
    def __init__(self):
        pass


    def insert(self, element, index): 
        '''insert(self, element, index)
Arguments:
	[in]	element = MAttributeSpec
	[in]	index = int


Inserts a new value into the array at the given index. The initial element at that index, and all following elements, are shifted towards the last.'''
        pass

    def set(self, element, index): 
        '''set(self, element, index)
Arguments:
	[in]	element = MAttributeSpec
	[in]	index = int


Sets the value of the specified element to the given attribute spec.'''
        pass

    def __getitem__(self, index): 
        '''__getitem__(self, index) -> MAttributeSpec
Returns: A reference to the specified element 

Arguments:
	[in]	index = int


Index operator. Returns the value of the element at the given index. Valid indices are 0 to  length() -1.'''
        pass

    def clear(self): 
        '''clear(self)

Clear the contents of the array. After this operation the length method will return 0. This does not change the amount of memory allocated to the array, only the number of valid elements in it.'''
        pass

    def sizeIncrement(self): 
        '''sizeIncrement(self) -> int


Return the size by which the array will be expanded whenever expansion is necessary.'''
        pass

    def remove(self, index): 
        '''remove(self, index)
Arguments:
	[in]	index = int


Removes the element in the array at the given index.'''
        pass

    def length(self): 
        '''length(self) -> int


Returns the number of elements in the array.'''
        pass

    def setSizeIncrement(self, newIncrement): 
        '''setSizeIncrement(self, newIncrement)
Arguments:
	[in]	newIncrement = int


Set the size by which the array will be expanded whenever expansion is necessary.'''
        pass

    def setLength(self, length): 
        '''setLength(self, length)
Arguments:
	[in]	length = int


Set the length of the array. This will grow and shrink the array as desired. Elements that are grown have uninitialized values, while those which are shrunk will lose the data contained in the deleted elements (ie. it will release the memory).'''
        pass

    def append(self, element): 
        '''append(self, element)
Arguments:
	[in]	element = MAttributeSpec


Adds a new element to the end of the array.'''
        pass

class MBoundingBox:
    '''Implementation of a 3D bounding box. This class provides an implementation of a bounding box. A bounding box describes a volume in space that bounds a piece of geometry. The box is defined by two points which describe the minimum and maximum corners of the box. '''
    def __init__(self):
        pass


    def intersects(self, box, tol): 
        '''intersects(self, box, tol) -> bool
Returns: true if the bounding boxes intersect 

Arguments:
	[in]	box = MBoundingBox
	[in]	tol = double


Returns true if the bounding box intersects another given bounding box'''
        pass

    def center(self): 
        '''center(self) -> MPoint


Returns the center of the bounding box.'''
        pass

    def min(self): 
        '''min(self) -> MPoint


Returns the minimum point for the bounding box. That is the point whose x, y, and z components represent the bounding box's minimum value in each dimension.'''
        pass

    def max(self): 
        '''max(self) -> MPoint


Returns the maximum point for the bounding box. That is the point whose x, y, and z components represent the bounding box's maximum value in each dimension.'''
        pass

    def clear(self): 
        '''clear(self)
'''
        pass

    def contains(self, point): 
        '''contains(self, point) -> bool
Returns: true if the point is contained in this bounding box 

Arguments:
	[in]	point = MPoint


Returns true if the bounding box contains the given point.'''
        pass

    def transformUsing(self, matrix): 
        '''transformUsing(self, matrix)
Arguments:
	[in]	matrix = MMatrix


Apply the given transformation to this bounding box.'''
        pass

    def height(self): 
        '''height(self) -> double


Returns the height of the bounding box.'''
        pass

    def width(self): 
        '''width(self) -> double


Returns the width of the bounding box.'''
        pass

    def depth(self): 
        '''depth(self) -> double


Returns the depth of the bounding box.'''
        pass

    def expand(self, box): 
        '''expand(self, box)
Arguments:
	[in]	box = MBoundingBox


Expand the bounding box to include a second bounding box.'''
        pass

class MCallbackIdArray:
    '''Array of MCallbackId data type. This class implements an array of MCallbackId. Common convenience functions are available, and the implementation is compatible with the internal Maya implementation so that it can be passed efficiently between plugins and internal maya data structures. '''
    def __init__(self):
        pass


    def insert(self, element, index): 
        '''insert(self, element, index)
Arguments:
	[in]	element = MCallbackId
	[in]	index = int


Inserts a new value into the array at the given index. The initial element at that index, and all following elements, are shifted towards the last. If the array cannot be expanded in size by 1 element, then the insert will fail and the existing array will remain unchanged.'''
        pass

    def set(self, element, index): 
        '''set(self, element, index)
Arguments:
	[in]	element = MCallbackId
	[in]	index = int


Sets the value of the indicated element to the indicated value.'''
        pass

    def __getitem__(self, index): 
        '''__getitem__(self, index) -> MCallbackId
Returns: The value of the indicated element. 

Arguments:
	[in]	index = int


Index operator. Returns the value of the element at the given index. No range checking is done - valid indices are 0 to  length() -1.'''
        pass

    def clear(self): 
        '''clear(self)

Clear the contents of the array. After this operation the length method will return 0. This does not change the amount of memory allocated to the array, only the number of valid elements in it.'''
        pass

    def sizeIncrement(self): 
        '''sizeIncrement(self) -> int


Return the size by which the array will be expanded whenever expansion is necessary.'''
        pass

    def remove(self, index): 
        '''remove(self, index)
Arguments:
	[in]	index = int


Remove the array element at the given index. All array elements following the removed element are shifted toward the first element.'''
        pass

    def length(self): 
        '''length(self) -> int


Returns the number of elements in the instance.'''
        pass

    def setSizeIncrement(self, newIncrement): 
        '''setSizeIncrement(self, newIncrement)
Arguments:
	[in]	newIncrement = int


Set the size by which the array will be expanded whenever expansion is necessary.'''
        pass

    def copy(self, source): 
        '''copy(self, source)
Arguments:
	[in]	source = MCallbackIdArray


Copy the contents of the source array to this array.'''
        pass

    def setLength(self, length): 
        '''setLength(self, length)
Arguments:
	[in]	length = int


Set the length of the array. This will grow and shrink the array as desired. Elements that are grown have uninitialized values, while those which are shrunk will lose the data contained in the deleted elements (ie. it will release the memory).'''
        pass

    def append(self, element): 
        '''append(self, element)
Arguments:
	[in]	element = MCallbackId


Adds a new element to the end of the array. If the array cannot be expanded in size by 1 element, then the append will fail and the existing array will remain unchanged.'''
        pass

class MColor:
    '''A color math class. This class is used to store values of color attributes. Its structure is compatible with that of the internal T4dFltVector class. Right now, this class provides no more functionality than the MFltVector class, but it is used because Rendering plans to employ more advanced color models in the future. In these models, colors cannot necessarily be represented as an RGB triple. '''
    def __init__(self):
        pass


    def set(self, colorModel, c1, c2, c3, alpha): 
        '''set(self, colorModel, c1, c2, c3, alpha) -> bool
Returns: Always returns bool true. 

Arguments:
	[in]	colorModel = MColor.MColorType
	[in]	c1 = float
	[in]	c2 = float
	[in]	c3 = float
	[in]	alpha = float


Color component assigment. 
'''
        pass

    def __getitem__(self, i): 
        '''__getitem__(self, i) -> float
Returns: A reference to the appropriate component of the color: 
Reference to the red channel when argument is 0. 
Reference to the green channel when argument is 1. 
Reference to the blue channel when argument is 2. 
Reference to the alpha channel otherwise. 

Arguments:
	[in]	i = int


Index operator. 
'''
        pass

    def get(self, colorModel, c1, c2, c3, alpha): 
        '''get(self, colorModel, c1, c2, c3, alpha) -> bool
Returns: Always returns bool true. 

Arguments:
	[in]	colorModel = MColor.MColorType
	[out]	c1 = float
	[out]	c2 = float
	[out]	c3 = float
	[out]	alpha = float


Color component accessor. 
'''
        pass

    def kCMY(self):
        '''This is an enum of MColorType.
Description: Cyan, Magenta, Yellow.
Value: 2'''
        pass

    def kHSV(self):
        '''This is an enum of MColorType.
Description: Hue, Saturation, Value.
Value: 1'''
        pass

    def kRGB(self):
        '''This is an enum of MColorType.
Description: Red, Green, Blue.
Value: 0'''
        pass

    def kCMYK(self):
        '''This is an enum of MColorType.
Description: Cyan, Magenta, Yellow, Black.
Value: 3'''
        pass

    class MColorType:
        '''Non-functional class.  Values for this enum:
        kCMY
        kHSV
        kRGB
        kCMYK
'''
        def __init__(self):
            pass

    def __rmult__(self, other): 
        '''__rmult__(self, other) -> MColor
Returns: A reference to the color whose value was modified. 

Arguments:
	[in]	other = MColor


In place multiply operator. 
'''
        pass

    def __radd__(self, other): 
        '''__radd__(self, other) -> MColor
Returns: A reference to the color whose value was modified. 

Arguments:
	[in]	other = MColor


In place add operator. 
'''
        pass

    def __div__(self, scalar): 
        '''__div__(self, scalar) -> MColor
Returns: A new MColor object representing the color divided by the scalar. 

Arguments:
	[in]	scalar = float


Divide operator. 
'''
        pass

    def __mul__(self, other): 
        '''__mul__(self, other) -> MColor
Returns: A new MColor object representing the product of the two colors. 

Arguments:
	[in]	other = MColor


Multiply operator. 
'''
        pass

    def __add__(self, other): 
        '''__add__(self, other) -> MColor
Returns: A new MColor object representing the sum of this color and the specified color. 

Arguments:
	[in]	other = MColor


Add operator. 
'''
        pass

    def __rdiv__(self, scalar): 
        '''__rdiv__(self, scalar) -> MColor
Returns: A reference to the color whose value was modified. 

Arguments:
	[in]	scalar = float


In place divide operator. 
'''
        pass

    def __sub__(self, other): 
        '''__sub__(self, other) -> MColor
Returns: A new MColor object representing this color minus the specified other color. 

Arguments:
	[in]	other = MColor


Substraction operator. 
'''
        pass

    def __eq__(self, other): 
        '''__eq__(self, other) -> bool
Returns: A bool value: 
true if the colors are identical 
false otherwise 

Arguments:
	[in]	other = MColor


Equality operator. 
'''
        pass

    def __neq__(self, other): 
        '''__neq__(self, other) -> bool
Returns: A bool value: 
false if the colors are identical 
true otherwise 

Arguments:
	[in]	other = MColor


Inequality operator. 
'''
        pass

class MColorArray:
    '''Array of MColor data type. This class implements an array of MColor's. Common convenience functions are available, and the implementation is compatible with the internal Maya implementation so that it can be passed efficiently between plugins and internal maya data structures. '''
    def __init__(self):
        pass


    def insert(self, element, index): 
        '''insert(self, element, index)
Arguments:
	[in]	element = MColor
	[in]	index = int


Inserts a new value into the array at the given index. The initial element at that index, and all following elements, are shifted towards the last. If the array cannot be expanded in size by 1 element, then the insert will fail and the existing array will remain unchanged.'''
        pass

    def set(self, elements, size): 
        '''set(self, elements, size)
Arguments:
	[in]	elements = double
	[in]	size = int


Resets the values of the color components. The length of the passed in C++ array should be same as the length of the ColorArray to which we are setting the values.'''
        pass

    def get(self, dest): 
        '''get(self, dest)
Arguments:
	[out]	dest = float


Copy the elements of the array into the C++ array of float arrays. No checking is done to ensure that the destination C++ array of float arrays is large enough to hold all the elements of the instance.'''
        pass

    def clear(self): 
        '''clear(self)

Clear the contents of the array. After this operation the length method will return 0. This does not change the amount of memory allocated to the array, only the number of valid elements in it.'''
        pass

    def sizeIncrement(self): 
        '''sizeIncrement(self) -> int


Return the size by which the array will be expanded whenever expansion is necessary.'''
        pass

    def remove(self, index): 
        '''remove(self, index)
Arguments:
	[in]	index = int


Remove the array element at the given index. All array elements following the removed element are shifted toward the first element.'''
        pass

    def length(self): 
        '''length(self) -> int


Returns the number of elements in the instance.'''
        pass

    def MColor(self, index): 
        '''MColor(self, index) -> const
Returns: The value of the indicated element. 

Arguments:
	[in]	index = int


Index operator. Returns the value of the element at the given index. No range checking is done - valid indices are 0 to  length() -1.'''
        pass

    def setSizeIncrement(self, newIncrement): 
        '''setSizeIncrement(self, newIncrement)
Arguments:
	[in]	newIncrement = int


Set the size by which the array will be expanded whenever expansion is necessary.'''
        pass

    def setLength(self, length): 
        '''setLength(self, length)
Arguments:
	[in]	length = int


Set the length of the array. This will grow and shrink the array as desired. Elements that are grown have uninitialized values, while those which are shrunk will lose the data contained in the deleted elements (ie. it will release the memory).'''
        pass

    def append(self, x, y, z, w): 
        '''append(self, x, y, z, w)
Arguments:
	[in]	x = float
	[in]	y = float
	[in]	z = float
	[in]	w = float


Adds a new element to the end of the array. The appended element has the indicated values for its x,y,z and w components. The x component of the element is set to x, the y component to y, the z component to z, and the w component to w.'''
        pass

class MCommandMessage:
    '''Helper class to handle MEL output. This class is used to register for a callback for when certain MEL command related messages are generated.The add callback method returns an id which is used to remove the callback.To remove a callback use MMessage::removeCallback.All callbacks that are registered by a plug-in must be removed by that plug-in when it is unloaded. Failure to do so will result in a fatal error.'''
    def __init__(self):
        pass


    def addCommandOutputCallback(self, func, clientData): 
        '''addCommandOutputCallback(self, func, clientData) -> MCallbackId
Returns: Identifier used for removing the callback.

Arguments:
	[in]	func = MCommandMessage.MMessageFunction
	[in]	clientData = void


This method registers a callback for whenever MEL commands generate output such as that which is printed into the command window.'''
        pass

    def addCommandCallback(self, func, clientData): 
        '''addCommandCallback(self, func, clientData) -> MCallbackId
Returns: Identifier used for removing the callback.

Arguments:
	[in]	func = MMessage.MStringFunction
	[in]	clientData = void


This method registers a callback for command messages that are issued every time a MEL command is executed. It is only called when actual commands are executed and not when scripts are executed.'''
        pass

    def addCommandOutputFilterCallback(self, func, clientData): 
        '''addCommandOutputFilterCallback(self, func, clientData) -> MCallbackId
Returns: Identifier used for removing the callback.

Arguments:
	[in]	func = MCommandMessage.MMessageFilterFunction
	[in]	clientData = void


This method registers a callback for whenever MEL commands generate output such as that which is printed into the command window.'''
        pass

    def kStackTrace(self):
        '''This is an enum of MessageType.
Description: Stack trace.
Value: 6'''
        pass

    def kInfo(self):
        '''This is an enum of MessageType.
Description: General information.
Value: 2'''
        pass

    def kHistory(self):
        '''This is an enum of MessageType.
Description: Command history.
Value: 0'''
        pass

    def kDisplay(self):
        '''This is an enum of MessageType.
Description: String to display unmodified.
Value: 1'''
        pass

    def kError(self):
        '''This is an enum of MessageType.
Description: Error message.
Value: 4'''
        pass

    def kResult(self):
        '''This is an enum of MessageType.
Description: Result from a command execution in the command window.
Value: 5'''
        pass

    def kWarning(self):
        '''This is an enum of MessageType.
Description: Warning message.
Value: 3'''
        pass

    class MessageType:
        '''Non-functional class.  Values for this enum:
        kStackTrace
        kInfo
        kHistory
        kDisplay
        kError
        kResult
        kWarning
'''
        def __init__(self):
            pass

class MCommandResult:
    '''Result returned from executing a command. MCommandResult collects the result returned by MGlobal::executeCommand. It can either be an int or an array of int or a double or an array of double or a string or an array of string. Use resultType to find out its type and use the appropriate getResult method to retrieve the result. '''
    def __init__(self):
        pass


    def resultType(self): 
        '''resultType(self) -> MCommandResult.Type
Returns: MCommandResult::kInt 
MCommandResult::kIntArray 
MCommandResult::kDouble 
MCommandResult::kDoubleArray 
MCommandResult::kString 
MCommandResult::kStringArray 
MCommandResult::kVector 
MCommandResult::kVectorArray 
MCommandResult::kMatrix 
MCommandResult::kInvalid 


Returns the type of the result.'''
        pass

    def kDouble(self):
        '''This is an enum of Type.
Description: 
Value: 3'''
        pass

    def kIntArray(self):
        '''This is an enum of Type.
Description: 
Value: 2'''
        pass

    def kStringArray(self):
        '''This is an enum of Type.
Description: 
Value: 6'''
        pass

    def kVectorArray(self):
        '''This is an enum of Type.
Description: 
Value: 8'''
        pass

    def kInt(self):
        '''This is an enum of Type.
Description: 
Value: 1'''
        pass

    def kString(self):
        '''This is an enum of Type.
Description: 
Value: 5'''
        pass

    def kDoubleArray(self):
        '''This is an enum of Type.
Description: 
Value: 4'''
        pass

    def kInvalid(self):
        '''This is an enum of Type.
Description: 
Value: 0'''
        pass

    def kMatrixArray(self):
        '''This is an enum of Type.
Description: 
Value: 10'''
        pass

    def kVector(self):
        '''This is an enum of Type.
Description: 
Value: 7'''
        pass

    def kMatrix(self):
        '''This is an enum of Type.
Description: 
Value: 9'''
        pass

    class Type:
        '''Non-functional class.  Values for this enum:
        kDouble
        kIntArray
        kStringArray
        kVectorArray
        kInt
        kString
        kDoubleArray
        kInvalid
        kMatrixArray
        kVector
        kMatrix
'''
        def __init__(self):
            pass

    def stringResult(self): 
        '''stringResult(self) -> MString
Returns: The command result


Retrieves the command result which is a string.'''
        pass

    def getResult(self, result, numRows, numColumns): 
        '''getResult(self, result, numRows, numColumns)
Arguments:
	[out]	result = MDoubleArray
	[out]	numRows = int
	[out]	numColumns = int


Retrieves the command result which is a matrix.'''
        pass

class MComputation:
    '''Interupt monitor for long computations. An MComputation allows long computations to check for user interrupts. It is very simple to use. Create a new  object and call the  method at the beginning of the computation and call the  method when you finish. Then, during the computation, use the  method to check if the user has requested that the computation terminate. (of a simple traversal)'''
    def __init__(self):
        pass


    def beginComputation(self): 
        '''beginComputation(self)

Mark the beginning of a long computation. The application will begin looking for user interupts. 
  Reprocessed example  
 Examples: 
 
   
 animInfoCmd.cpp . 
 
'''
        pass

    def isInterruptRequested(self): 
        '''isInterruptRequested(self) -> bool


Query whether a user-interrupt has occurred.'''
        pass

    def endComputation(self): 
        '''endComputation(self)

Mark the ending of a long computation. The application will stop looking for user interupts. 
  Reprocessed example  
 Examples: 
 
   
 animInfoCmd.cpp . 
 
'''
        pass

class MConditionMessage:
    '''Condition change messages. This class is used to register callbacks for changes to specific conditions.The addConditionCallback method will add callback a callback for condition changed messages.The first parameter passed to the addConditionCallback method is the name of the condition that will trigger the callback. The list of available condition names can be retrieved by calling the getConditionNames method or by using the -listConditions flag on the scriptJob command.Callbacks that are registered for conditions will be passed a bool value as a parameter. This value indicates the new state of the condition.The addConditionCallback method returns an id which is used to remove the callback.To remove a callback use MMessage::removeCallback.All callbacks that are registered by a plug-in must be removed by that plug-in when it is unloaded. Failure to do so will result in a fatal error.The getConditionState method is used to return the current state of the specified condition. '''
    def __init__(self):
        pass


    def getConditionNames(self, names): 
        '''getConditionNames(self, names)
Arguments:
	[out]	names = MStringArray


This method returns the list of available condition names.'''
        pass

    def addConditionCallback(self, conditionName, func, clientData): 
        '''addConditionCallback(self, conditionName, func, clientData) -> MCallbackId

Arguments:
	[in]	conditionName = MString
	[in]	func = MMessage.MStateFunction
	[in]	clientData = void


This method registers a callback for condition changed messages.'''
        pass

    def getConditionState(self, name): 
        '''getConditionState(self, name) -> bool
Returns: The current state of the condition.

Arguments:
	[in]	name = MString


This method returns the current state of a condition.'''
        pass

class MContainerMessage:
    '''Container-related messages. The container node in Maya bundles together a group of related nodes. The user can then publish attribute names to the container, and bind attributes from nodes in the container to the published names.MContainerMessage class allows the API user to register callbacks that inform them about changes to published attributes on containers.To remove a callback use MMessage::removeCallback. All callbacks that are registered by a plug-in must be removed by that plug-in when it is unloaded. Failure to do so will result in a fatal error. '''
    def __init__(self):
        pass


    def addPublishAttrCallback(self, func, clientData): 
        '''addPublishAttrCallback(self, func, clientData) -> MCallbackId
Returns: Identifier used for removing the callback.

Arguments:
	[in]	func = MMessage.MNodeStringBoolFunction
	[in]	clientData = void


This method registers a callback that is called whenever an attribute is published or unpublished from a container.'''
        pass

    def addBoundAttrCallback(self, func, clientData): 
        '''addBoundAttrCallback(self, func, clientData) -> MCallbackId
Returns: Identifier used for removing the callback.

Arguments:
	[in]	func = MMessage.MNodeStringBoolFunction
	[in]	clientData = void


This method registers a callback that is called whenever an attribute is bound or unbound on a container.'''
        pass

class MDagMessage:
    '''Dependency graph messages. This class is used to register callbacks for dependency graph messages.There are 6 types of add callback methods which will add callbacks for the following messagesMethods exist to register callbacks for every time any DAG node is affected as well as methods that work on specific nodes. Each method returns an id which is used to remove the callback.To remove a callback use MMessage::removeCallback. All callbacks that are registered by a plug-in must be removed by that plug-in when it is unloaded. Failure to do so will result in a fatal error.NOTE: It is possible to get Parent Added and Child Added messages before the node name has been set. This can happen if the node is newly created. Additionally, the MDagPath string path names passed to the callback may not be set as yet if the node has not been added to the model. '''
    def __init__(self):
        pass


    def addInstanceRemovedCallback(self, func, clientData): 
        '''addInstanceRemovedCallback(self, func, clientData) -> MCallbackId

Arguments:
	[in]	func = MMessage.MParentChildFunction
	[in]	clientData = void


This method registers a callback that is called whenever an instance of any DAG node is removed or deleted.'''
        pass

    def addParentRemovedCallback(self, func, clientData): 
        '''addParentRemovedCallback(self, func, clientData) -> MCallbackId

Arguments:
	[in]	func = MMessage.MParentChildFunction
	[in]	clientData = void


This method registers a callback that is called whenever a parent is removed in the DAG.'''
        pass

    def addDagCallback(self, dagPath, msgType, func, clientData): 
        '''addDagCallback(self, dagPath, msgType, func, clientData) -> MCallbackId

Arguments:
	[in]	dagPath = MDagPath
	[in]	msgType = MDagMessage.DagMessage
	[in]	func = MMessage.MParentChildFunction
	[in]	clientData = void


Obsolete and no script support. 
'''
        pass

    def addChildRemovedCallback(self, func, clientData): 
        '''addChildRemovedCallback(self, func, clientData) -> MCallbackId

Arguments:
	[in]	func = MMessage.MParentChildFunction
	[in]	clientData = void


This method registers a callback that is called whenever a child is removed in the DAG.'''
        pass

    def addParentAddedCallback(self, func, clientData): 
        '''addParentAddedCallback(self, func, clientData) -> MCallbackId

Arguments:
	[in]	func = MMessage.MParentChildFunction
	[in]	clientData = void


This method registers a callback that is called whenever a parent is added in the DAG.'''
        pass

    def addDagDagPathCallback(self, dagPath, msgType, func, clientData): 
        '''addDagDagPathCallback(self, dagPath, msgType, func, clientData) -> MCallbackId

Arguments:
	[in]	dagPath = MDagPath
	[in]	msgType = MDagMessage.DagMessage
	[in]	func = MDagMessage.MMessageParentChildFunction
	[in]	clientData = void


This method registers a callback that is called for specified a DAG change is made to the specified DAG path. The callback receives the DagMessage as well.'''
        pass

    def addChildAddedCallback(self, func, clientData): 
        '''addChildAddedCallback(self, func, clientData) -> MCallbackId

Arguments:
	[in]	func = MMessage.MParentChildFunction
	[in]	clientData = void


This method registers a callback that is called whenever a child is added in the DAG.'''
        pass

    def addParentRemovedDagPathCallback(self, node, func, clientData): 
        '''addParentRemovedDagPathCallback(self, node, func, clientData) -> MCallbackId

Arguments:
	[in]	node = MDagPath
	[in]	func = MMessage.MParentChildFunction
	[in]	clientData = void


This method registers a callback that is called whenever a parent is removed from the specified DAG node.'''
        pass

    def addChildAddedDagPathCallback(self, node, func, clientData): 
        '''addChildAddedDagPathCallback(self, node, func, clientData) -> MCallbackId

Arguments:
	[in]	node = MDagPath
	[in]	func = MMessage.MParentChildFunction
	[in]	clientData = void


This method registers a callback that is called whenever a child is added to the specified DAG node.'''
        pass

    def addAllDagChangesDagPathCallback(self, dagPath, func, clientData): 
        '''addAllDagChangesDagPathCallback(self, dagPath, func, clientData) -> MCallbackId

Arguments:
	[in]	dagPath = MDagPath
	[in]	func = MDagMessage.MMessageParentChildFunction
	[in]	clientData = void


This method registers a callback that is called whenever a DAG change is made to the specified DAG path.'''
        pass

    def addInstanceAddedDagPathCallback(self, dagPath, func, clientData): 
        '''addInstanceAddedDagPathCallback(self, dagPath, func, clientData) -> MCallbackId

Arguments:
	[in]	dagPath = MDagPath
	[in]	func = MMessage.MParentChildFunction
	[in]	clientData = void


This method registers a callback that is called whenever the specified node is instanced'''
        pass

    def addParentAddedDagPathCallback(self, node, func, clientData): 
        '''addParentAddedDagPathCallback(self, node, func, clientData) -> MCallbackId

Arguments:
	[in]	node = MDagPath
	[in]	func = MMessage.MParentChildFunction
	[in]	clientData = void


This method registers a callback that is called whenever a parent is added to the specified DAG node..'''
        pass

    def addInstanceAddedCallback(self, func, clientData): 
        '''addInstanceAddedCallback(self, func, clientData) -> MCallbackId

Arguments:
	[in]	func = MMessage.MParentChildFunction
	[in]	clientData = void


This method registers a callback that is called whenever any node in the DAG is instanced'''
        pass

    def kChildReordered(self):
        '''This is an enum of DagMessage.
Description: a child of a DAG node was reordered
Value: 4'''
        pass

    def kInstanceAdded(self):
        '''This is an enum of DagMessage.
Description: a DAG node was instanced
Value: 5'''
        pass

    def kChildRemoved(self):
        '''This is an enum of DagMessage.
Description: a child was removed from a DAG node
Value: 3'''
        pass

    def kParentRemoved(self):
        '''This is an enum of DagMessage.
Description: a parent was removed from a DAG node
Value: 1'''
        pass

    def kInstanceRemoved(self):
        '''This is an enum of DagMessage.
Description: a DAG node instance was removed
Value: 6'''
        pass

    def kLast(self):
        '''This is an enum of DagMessage.
Description: last value of the enum
Value: 7'''
        pass

    def kInvalidMsg(self):
        '''This is an enum of DagMessage.
Description: an invalid message was used.
Value: -1'''
        pass

    def kChildAdded(self):
        '''This is an enum of DagMessage.
Description: a child was added to a DAG node
Value: 2'''
        pass

    def kParentAdded(self):
        '''This is an enum of DagMessage.
Description: a dummy enum used for looping through the message types
Value: 0'''
        pass

    class DagMessage:
        '''Non-functional class.  Values for this enum:
        kChildReordered
        kInstanceAdded
        kChildRemoved
        kParentRemoved
        kInstanceRemoved
        kLast
        kInvalidMsg
        kChildAdded
        kParentAdded
'''
        def __init__(self):
            pass

    def addInstanceRemovedDagPathCallback(self, dagPath, func, clientData): 
        '''addInstanceRemovedDagPathCallback(self, dagPath, func, clientData) -> MCallbackId

Arguments:
	[in]	dagPath = MDagPath
	[in]	func = MMessage.MParentChildFunction
	[in]	clientData = void


This method registers a callback that is called whenever an instance of the specified node is removed.'''
        pass

    def addChildRemovedDagPathCallback(self, node, func, clientData): 
        '''addChildRemovedDagPathCallback(self, node, func, clientData) -> MCallbackId

Arguments:
	[in]	node = MDagPath
	[in]	func = MMessage.MParentChildFunction
	[in]	clientData = void


This method registers a callback that is called whenever a child is removed from the specified DAG node.'''
        pass

    def addAllDagChangesCallback(self, func, clientData): 
        '''addAllDagChangesCallback(self, func, clientData) -> MCallbackId

Arguments:
	[in]	func = MDagMessage.MMessageParentChildFunction
	[in]	clientData = void


This method registers a callback that is called whenever any DAG change is made to any DAG node.'''
        pass

    def addChildReorderedCallback(self, func, clientData): 
        '''addChildReorderedCallback(self, func, clientData) -> MCallbackId

Arguments:
	[in]	func = MMessage.MParentChildFunction
	[in]	clientData = void


This method registers a callback that is called whenever a child is reordered in the DAG.'''
        pass

    def addChildReorderedDagPathCallback(self, node, func, clientData): 
        '''addChildReorderedDagPathCallback(self, node, func, clientData) -> MCallbackId

Arguments:
	[in]	node = MDagPath
	[in]	func = MMessage.MParentChildFunction
	[in]	clientData = void


This method registers a callback that is called whenever a child of the specified DAG node is reordered.'''
        pass

class MDagModifier:
    '''Dependency graph modifier. An MDagModifier is used to change the structure of the DAG. This includes adding nodes, making new connections, and removing existing connections. To perform operations using an MDagModifier, register all of the changes that are to be made and then call the doIt method to make the changes. Undo is provided through the undoIt method. '''
    def __init__(self):
        pass


    def createNode(self, type, parent): 
        '''createNode(self, type, parent) -> MObject
Returns: A handle for the new node, or the transform above if one is created as a parent.

Arguments:
	[in]	type = MString
	[in]	parent = MObject


This method adds an operation to this DAG modifier that will add a new node of the given type to the DAG. This method may not be used to construct new dependency graph nodes that are not in the DAG. Use  MDGModifier  for that purpose.'''
        pass

    def reparentNode(self, node, newParent): 
        '''reparentNode(self, node, newParent)
Arguments:
	[in]	node = MObject
	[out]	newParent = MObject


This method adds an operation to this DAG modifier that will reparent a node in the DAG. If the parent passed in is NULL, then the node will be reparented under the world.'''
        pass

class MDagPath:
    '''DAG Path. Provides methods for obtaining one or all Paths to a specified DAG Node, determining if a Path is valid and if two Paths are equivalent, obtaining the length, transform, and inclusive and exclusive matrices of a Path, as well as performing Path to Path assignment.DAG Paths may be used as parameters to some methods in the DAG Node Function Set (MFnDagNode).It is often useful to combine DAG Paths into DAG Path arrays (MDagPathArray).Use this DAG Path Class to obtain and query Paths to DAG Nodes. A DAG path is a path from the world node to a particular object in the DAG.If a DAG object is instanced, then an MDagPath is required to identify a particular instance. DAG paths are also required when doing world space transformations.Use this class in conjunction with the DAG Iterator (MItDag), DAG Node Function Set (MFnDagNode) and DAG Path Array class (MDagPathArray) to query and edit the DAG. '''
    def __init__(self):
        pass


    def set(self, src): 
        '''set(self, src)
Arguments:
	[in]	src = MDagPath


Sets this DAG Path equal to the specified DAG Path.'''
        pass

    def fullPathName(self): 
        '''fullPathName(self) -> MString
Returns: The full path name


Return a string representing the full path from the root of the dag to this object.'''
        pass

    def pop(self, num): 
        '''pop(self, num)
Arguments:
	[in]	num = int


Pop the given number of objects off of the end of the path.'''
        pass

    def getAPathTo(self, entity): 
        '''getAPathTo(self, entity) -> MDagPath

Arguments:
	[in]	entity = MObject

'''
        pass

    def hasFn(self, type): 
        '''hasFn(self, type) -> bool
Returns: Boolean value indicating whether the function set is supported

Arguments:
	[in]	type = MFn.Type


Returns true if the object at the end of this DAG path supports the given function set.'''
        pass

    def partialPathName(self): 
        '''partialPathName(self) -> MString
Returns: The partial path name


Return a string representing the partial path from the root of the dag to this object.'''
        pass

    def transform(self): 
        '''transform(self) -> MObject
Returns: Lowest Transform for this DAG Path


Retrieves the lowest Transform in the DAG Path.'''
        pass

    def getPath(self, i, path): 
        '''getPath(self, i, path)
Arguments:
	[out]	path = MDagPath
	[in]	i = int


Return the i'th path. The zero'th path is the top-most path and must be rooted by the world. Additional paths are paths in the underworld of the object at the end of the previous path (path i-1).'''
        pass

    def numberOfShapesDirectlyBelow(self, num): 
        '''numberOfShapesDirectlyBelow(self, num)
Arguments:
	[out]	num = int


If the object at the end of this path is a transform, this method will return the number of shapes directly below the transform.'''
        pass

    def childCount(self): 
        '''childCount(self) -> int
Returns: The number of children


Return the number of children that the object at the end of the path has.'''
        pass

    def node(self): 
        '''node(self) -> MObject
Returns: DAG Node for this DAG Path


Retrieves the DAG Node for this DAG Path.'''
        pass

    def inclusiveMatrix(self): 
        '''inclusiveMatrix(self) -> MMatrix
Returns: The matrix for all Transforms in the Path including the the end Node in the Path if it is a Transform


Determines the inclusive matrix of the Path.'''
        pass

    def getAllPathsTo(self, object, pathArray): 
        '''getAllPathsTo(self, object, pathArray)
Arguments:
	[in]	object = MObject
	[out]	pathArray = MDagPathArray


Determines all Paths to the specified DAG Node.'''
        pass

    def extendToShapeDirectlyBelow(self, index): 
        '''extendToShapeDirectlyBelow(self, index)
Arguments:
	[in]	index = int


This method is used if the end of the path is a transform and there are shapes directly below the transform. The shape to extend to is set by passing in an appropriate index parameter.'''
        pass

    def isValid(self): 
        '''isValid(self) -> bool
Returns: True if valid


Determines if Path is valid.'''
        pass

    def apiType(self): 
        '''apiType(self) -> MFn.Type
Returns: Type of the object


Returns the type of the object at the end of the path.'''
        pass

    def pathCount(self): 
        '''pathCount(self) -> int
Returns: The path count


Return the number of paths which make up this path.'''
        pass

    def child(self, index): 
        '''child(self, index) -> MObject
Returns: A handle to the child

Arguments:
	[in]	index = int


Return the child object at the given index, where the parent is the object at the end of the path.'''
        pass

    def __eq__(self, src): 
        '''__eq__(self, src) -> bool

Arguments:
	[in]	src = MDagPath


Determines if the DAG Path on the LHS of the operator is equal to the DAG Path on the RHS.'''
        pass

    def inclusiveMatrixInverse(self): 
        '''inclusiveMatrixInverse(self) -> MMatrix
Returns: The inverse of the matrix for all Transforms in the Path including the end Node in the Path if it is a Transform


Determines the inverse inclusive matrix of the Path.'''
        pass

    def extendToShape(self): 
        '''extendToShape(self)

If the object at the end of this path is a transform and there is a shape node directly beneath it in the hierarchy, then the path is extended to that geometry node.'''
        pass

    def exclusiveMatrixInverse(self): 
        '''exclusiveMatrixInverse(self) -> MMatrix
Returns: The inverse of the matrix for all transforms in the Path excluding the end Node in the Path if it is Transform


Determines the inverse exclusive matrix of the Path.'''
        pass

    def instanceNumber(self): 
        '''instanceNumber(self) -> int
Returns: The instance number represented by this path


For an instanced object, this returns the instance number that this path represents in the DAG. The instance number can be used to determine which element of the world space array attributes of a DAG node to connect to get information regarding this instance.'''
        pass

    def length(self): 
        '''length(self) -> int
Returns: Number of DAG Nodes not including the root


Determines the number of DAG Nodes in the Path not including the root.'''
        pass

    def exclusiveMatrix(self): 
        '''exclusiveMatrix(self) -> MMatrix
Returns: The matrix for all transforms in the Path excluding the end Node in the Path if it is Transform


Determines the exclusive matrix of the Path.'''
        pass

    def push(self, child): 
        '''push(self, child)
Arguments:
	[in]	child = MObject


Push an object onto the end of the path. The object must be a child of the object that is currently at the end of the path.'''
        pass

    def isInstanced(self): 
        '''isInstanced(self) -> bool
Returns: True if the DAG node at the end of the path is instanced


Returns true if the object at the end of the DAG path is instanced. It is instanced if there is more than one path to the node from the top of the DAG. Each instance of the node will be drawn separately in the view, but the geometry will be shared.'''
        pass

class MDagPathArray:
    '''Indexable Array of DAG Paths. Provides methods for manipulating arrays of DAG Paths.Arrays of DAG Paths are useful for storing and manipluating multiple Paths to a particular DAG Node. The DAG Path method MDagPath::getAllPathsTo() and DAG Node Function Set method MFnDagNode::getAllPaths() implicitly return an array of DAG Paths.These arrays may also be used to manage Paths for a number of different Nodes.DAG Path arrays are used in conjunction with DAG Paths (MDagPath) and individual elements of the arrays can be parameters to some methods of the DAG Node Function Set (MFnDagNode).Use this DAG Path Array Class to create and manipulate arrays of DAG Paths, for either a particular DAG Node or a number of different DAG Nodes.The length of the array adjusts automatically. '''
    def __init__(self):
        pass


    def insert(self, element, index): 
        '''insert(self, element, index)
Arguments:
	[in]	element = MDagPath
	[in]	index = int


Inserts the given DAG Path at the specified index in the array.'''
        pass

    def __getitem__(self, index): 
        '''__getitem__(self, index) -> MDagPath
Returns: DAG Path at the specified index 

Arguments:
	[in]	index = int


Retrieves the DAG Path which is at the specified index in the array.'''
        pass

    def clear(self): 
        '''clear(self)

Clears this array. Length of the array becomes zero.'''
        pass

    def MDagPath(self, index): 
        '''MDagPath(self, index) -> const
Returns: DAG Path at the specified index 

Arguments:
	[in]	index = int


Retrieves the read-only DAG Path which is at the specified index in the array.'''
        pass

    def remove(self, index): 
        '''remove(self, index)
Arguments:
	[in]	index = int


Removes the DAG Path which is at the specified index in the array.'''
        pass

    def length(self): 
        '''length(self) -> int


Determines the number of elements in the array.'''
        pass

    def setLength(self, length): 
        '''setLength(self, length)
Arguments:
	[in]	length = int


Set the length of the array. This will grow and shrink the array as desired. Elements that are grown have uninitialized values, while those which are shrunk will lose the data contained in the deleted elements (ie. it will release the memory).'''
        pass

    def append(self, element): 
        '''append(self, element)
Arguments:
	[in]	element = MDagPath


Appends the given DAG Path to the end of the array.'''
        pass

class MDataBlock:
    '''Dependency node data block. An MDataBlock provides storage for the data being received by or sent by the node. It is the data for the plugs and attributes of the node. The data block is only valid during the compute method of the depend node. Pointers to the data block should not be retained after the compute method.Access to the data in an MDataBlock is done using an MDataHandle or an MArrayDataHandle. '''
    def __init__(self):
        pass


    def setContext(self, ctx): 
        '''setContext(self, ctx)
Arguments:
	[in]	ctx = MDGContext


Set the dependency graph context for this data block. The context is used to specify how a dependency node is going to be evaluated, thus replacing the context for the given datablock. This does not modify the dirty state of the datablock so that they apply to the new context.'''
        pass

    def outputArrayValue(self, attribute): 
        '''outputArrayValue(self, attribute) -> MArrayDataHandle
Returns: Array data handle for the given attribute's data

Arguments:
	[in]	attribute = MObject


Gets a handle to this data block for the given attributes's data. The data is not guaranteed to be valid. No dependency graph evaluations will be done. Therefore, this handle should be used only for writing.'''
        pass

    def isClean(self, attribute): 
        '''isClean(self, attribute) -> bool

Arguments:
	[in]	attribute = MObject


Queries the dependency graph to see whether the given attribute is clean.'''
        pass

    def outputValue(self, attribute): 
        '''outputValue(self, attribute) -> MDataHandle
Returns: Data handle for the given attribute's data

Arguments:
	[in]	attribute = MObject


Gets a handle to this data block for the given attributes's data. The data is not guaranteed to be valid. No dependency graph evaluations will be done. Therefore, this handle should be used only for writing.'''
        pass

    def inputValue(self, attribute): 
        '''inputValue(self, attribute) -> MDataHandle
Returns: Data handle for the given attributes's data

Arguments:
	[in]	attribute = MObject


Gets a handle to this data block for the given plug's data. The data represented by the handle is guaranteed to be valid for reading. If the data is from a dirty connection, then the connection will be evaluated. If no connection is present, then the value that the plug has been set to will be returned. If the plug has not been set to a particular value, then the default value will be returned.'''
        pass

    def context(self): 
        '''context(self) -> MDGContext
Returns: The dependency graph context


Returns a copy of the dependecy graph context for which this data block was created. The context is used to specify how a dependency node is going to be evaluated.'''
        pass

    def setClean(self, attribute): 
        '''setClean(self, attribute)
Arguments:
	[in]	attribute = MObject


Tells the dependency graph that the given attribute has been updated and is now clean. This should be called after the data in the plug has been recalculated from the inputs of the node.'''
        pass

    def inputArrayValue(self, attribute): 
        '''inputArrayValue(self, attribute) -> MArrayDataHandle
Returns: Array data handle for the given attributes's data

Arguments:
	[in]	attribute = MObject


Gets an array handle to this data block for the given plug's data. This is only valid if the given plug has array data. The data represented by the handle will be valid. If the data is from a dirty connection, then the connection will be evaluated. If no connection is present, then the value that the plug has been set to will be returned. If the plug has not been set to a particular value, then the default value will be returned.'''
        pass

class MDataHandle:
    '''Data handle for information contained in a data block. An MDataHandle is a smart pointer into a data block (MDataBlock). A data handle corresponds to the data for a particular attribute or plug. For array data (eg CVs of a curve) use an MArrayDataHandle. To get a data handle, request it from the data block.Some simple numeric data is handled directly by the dependency graph. If the data is more complicated (eg surface geometry), then the data handle can supply a pointer that should be given to the appropriate data function set.MDataHandle allows the manipulation and setting of generic attributes as created by the MFnGenericAttribute class. It is possible to create numeric generic attributes using two scenarios. A plug-in may request that the generic attribute support singleton types such as MFnNumericData::kFloat or kChar. Or a plug-in may request array types such as MFnNumericData::k2Float k2Double. In the singleton case, getting and setting the attribute using MDataHandle is done with the asGeneric*() or setGeneric*() methods. In the case of the array types, the MDataHandle.data() method can be used to retrieve the MObject for the attribute and to initialize the MFnNumericData function set. A call to MDataHandle::setData() on the updated attribute must be made to pass the information back to Maya. NOTE: It is not possible to distinguish the singleton generic types from one another. There is no method that can be called to return if the singleton generic attribute is a float, char etc.MDataHandle methods cannot be assumed to be threadsafe. '''
    def __init__(self):
        pass


    def asFloat2(self): 
        '''asFloat2(self) -> float2&


Returns the data represented by this handle in the data block.'''
        pass

    def typeId(self): 
        '''typeId(self) -> MTypeId


Returns the type of data represented by this handle as a type id. A type id is a four character code that is used to identify the data type. If no data exists for this handle, the type id will be 0x0.'''
        pass

    def set3Short(self, val1, val2, val3): 
        '''set3Short(self, val1, val2, val3)
Arguments:
	[in]	val1 = short
	[in]	val2 = short
	[in]	val3 = short


Set the data that this handle represents in the data block.'''
        pass

    def set(self, data): 
        '''set(self, data)
Arguments:
	[in]	data = MPxData


No script support. 
'''
        pass

    def asInt3(self): 
        '''asInt3(self) -> int3&


Returns the data represented by this handle in the data block.'''
        pass

    def asInt2(self): 
        '''asInt2(self) -> int2&


Returns the data represented by this handle in the data block.'''
        pass

    def asDouble2(self): 
        '''asDouble2(self) -> double2&


Returns the data represented by this handle in the data block.'''
        pass

    def asFloat3(self): 
        '''asFloat3(self) -> float3&


Returns the data represented by this handle in the data block.'''
        pass

    def numericType(self): 
        '''numericType(self) -> MFnNumericData.Type


Returns the type of data represented by this handle. This method is only valid for data handles of simple numeric types.'''
        pass

    def child(self, attribute): 
        '''child(self, attribute) -> MDataHandle
Returns: The data handle for the child 

Arguments:
	[in]	attribute = MObject


Get a handle to a child of this handle. This is used if you have a handle to a compound attribute.'''
        pass

    def set3Float(self, val1, val2, val3): 
        '''set3Float(self, val1, val2, val3)
Arguments:
	[in]	val1 = float
	[in]	val2 = float
	[in]	val3 = float


Set the data that this handle represents in the data block.'''
        pass

    def asMeshTransformed(self): 
        '''asMeshTransformed(self) -> MObject


Returns the data represented by this handle in the data block. The object returned by this call may be used directly with the mesh function set ( MFnMesh ) or any of the mesh iterators.'''
        pass

    def asShort(self): 
        '''asShort(self) -> short&


Returns the data represented by this handle in the data block.'''
        pass

    def set2Double(self, val1, val2): 
        '''set2Double(self, val1, val2)
Arguments:
	[in]	val1 = double
	[in]	val2 = double


Set the data that this handle represents in the data block.'''
        pass

    def setMObject(self, data): 
        '''setMObject(self, data)
Arguments:
	[in]	data = MObject


Set the data that this handle represents in the data block. This method assumes that the  MObject  is a dependency graph data object. These objects can be created using the appropriate  MFn ..Data function set. Note that this method cannot be used to copy compound or multi attributes from one handle to another via the construct outputHandle.set (inputHandle.data()). To copy these user defined attributes, the method  MDataHandle::copy  must be used.'''
        pass

    def setBool(self, val): 
        '''setBool(self, val)
Arguments:
	[in]	val = bool


Set the data that this handle represents in the data block.'''
        pass

    def isNumeric(self): 
        '''isNumeric(self) -> bool


Returns true if this handle is for simple numeric data. That means that the numeric data is directly accessible through the non-generic as*() and set*() methods of this handle. For example, depending on handle initialization, the  asBool()  may be called but the  asGenericBool()  should not be called.'''
        pass

    def setMTime(self, val): 
        '''setMTime(self, val)
Arguments:
	[in]	val = MTime


Set the data that this handle represents in the data block.'''
        pass

    def asString(self): 
        '''asString(self) -> MString


Returns the data represented by this handle in the data block.'''
        pass

    def setMFloatMatrix(self, val): 
        '''setMFloatMatrix(self, val)
Arguments:
	[in]	val = MFloatMatrix


Set the data that this handle represents in the data block.'''
        pass

    def asPluginData(self): 
        '''asPluginData(self) -> MPxData


Returns the data represented by this handle in the data block. The object is returned as plugin data. This should be used to access data types defined by plugins.'''
        pass

    def setGenericDouble(self, value, force): 
        '''setGenericDouble(self, value, force)
Arguments:
	[in]	value = double
	[in]	force = bool


Set the data that this handle represents in the data block.'''
        pass

    def asMesh(self): 
        '''asMesh(self) -> MObject


Returns the data represented by this handle in the data block. The object returned by this call may be used directly with the mesh function set and iterators. Even though this method does not return a reference to an  MObject , modifications to the  MObject  instance will update the contents of the handle in the data block. The method  MDataHandle::setClean  should be called after the data block has been modified.'''
        pass

    def asChar(self): 
        '''asChar(self) -> char&


Returns the data represented by this handle in the data block.'''
        pass

    def copy(self, src): 
        '''copy(self, src)
Arguments:
	[in]	src = MDataHandle


Copies the attribute from the  src  attribute to the attribute referenced by this handle. This is the only method which can completely copy a compound attribute from one handle to another. The construct outputHandle.set (inputHandle.data()) will not work for compound or multi attributes.'''
        pass

    def setMMatrix(self, val): 
        '''setMMatrix(self, val)
Arguments:
	[in]	val = MMatrix


Set the data that this handle represents in the data block. This method is only valid for attributes created using the  MFnMatrixAttribute  function set.'''
        pass

    def MMatrix(self): 
        '''MMatrix(self) -> const


This method returns a reference to the local-to-world transformation matrix that can accompany a geometry data object. Only use this method on handles to geometry data (curves, surfaces, and meshes).'''
        pass

    def set2Int(self, val1, val2): 
        '''set2Int(self, val1, val2)
Arguments:
	[in]	val1 = int
	[in]	val2 = int


Set the data that this handle represents in the data block.'''
        pass

    def asDouble3(self): 
        '''asDouble3(self) -> double3&


Returns the data represented by this handle in the data block.'''
        pass

    def asGenericInt(self): 
        '''asGenericInt(self) -> int


Returns the generic data represented by this handle in the data block.'''
        pass

    def isGeneric(self, isNumeric, isNull): 
        '''isGeneric(self, isNumeric, isNull) -> bool
Returns: True will be returned if this handle points to a generic attribute 

Arguments:
	[out]	isNumeric = bool
	[out]	isNull = bool


Returns true if this handle is for generic data. There are 2 forms of generic data. The first is for simple data and is used if the isNumeric parameter returns true. In this case, the asGeneric*() and setGeneric*() methods of this class are used to query and set values. The second form of generic data is for more complex attribute types. As a result the type of the object must be checked and an appropriate attribute function set initialized with the object.'''
        pass

    def setChar(self, val): 
        '''setChar(self, val)
Arguments:
	[in]	val = char


Set the data that this handle represents in the data block.'''
        pass

    def asSubdSurface(self): 
        '''asSubdSurface(self) -> MObject


Returns the data represented by this handle in the data block. The object returned by this call may be used directly with the subdivision surface function set and iterator. Even though this method does not return a reference to an  MObject , modifications to the  MObject  instance will update the contents of the handle in the data block. The method  MDataHandle::setClean  should be called after the data block has been modified.'''
        pass

    def setMAngle(self, val): 
        '''setMAngle(self, val)
Arguments:
	[in]	val = MAngle


Set the data that this handle represents in the data block.'''
        pass

    def setGenericChar(self, value, force): 
        '''setGenericChar(self, value, force)
Arguments:
	[in]	value = char
	[in]	force = bool


Set the data that this handle represents in the data block.'''
        pass

    def asAngle(self): 
        '''asAngle(self) -> MAngle


Returns the data represented by this handle in the data block.'''
        pass

    def asGenericFloat(self): 
        '''asGenericFloat(self) -> float


Returns the generic data represented by this handle in the data block.'''
        pass

    def asFloat(self): 
        '''asFloat(self) -> float&


Returns the data represented by this handle in the data block.'''
        pass

    def asSubdSurfaceTransformed(self): 
        '''asSubdSurfaceTransformed(self) -> MObject


Returns the data represented by this handle in the data block. The object returned by this call may be used directly with the subdivision surface function set (MFnSubdSurface) or the subdivision surface iterators ( MItSubdVertex ,  MItSubdFace ,  MItSubdEdge ).'''
        pass

    def asMatrix(self): 
        '''asMatrix(self) -> MMatrix


Returns the data represented by this handle in the data block. This method is only valid for attributes created using the  MFnMatrixAttribute  function set.'''
        pass

    def type(self): 
        '''type(self) -> MFnData.Type


Returns the type of data represented by this handle.'''
        pass

    def setString(self, val): 
        '''setString(self, val)
Arguments:
	[in]	val = MString


Set the data that this handle represents in the data block.'''
        pass

    def asNurbsCurveTransformed(self): 
        '''asNurbsCurveTransformed(self) -> MObject


Returns the data represented by this handle in the data block. The object returned by this call may be used directly with the nurbs curve function set ( MFnNurbsCurve ) or the nurbs curve CV iterator ( MItCurveCV ).'''
        pass

    def asTime(self): 
        '''asTime(self) -> MTime


Returns the data represented by this handle in the data block. Even though this method does not return a reference to an  MTime , modifications to the  MTime  instance will update the contents of the handle in the data block. The method  MDataHandle::setClean  should be called after the data block has been modified.'''
        pass

    def setDouble(self, val): 
        '''setDouble(self, val)
Arguments:
	[in]	val = double


Set the data that this handle represents in the data block.'''
        pass

    def asGenericShort(self): 
        '''asGenericShort(self) -> short


Returns the generic data represented by this handle in the data block.'''
        pass

    def set2Short(self, val1, val2): 
        '''set2Short(self, val1, val2)
Arguments:
	[in]	val1 = short
	[in]	val2 = short


Set the data that this handle represents in the data block.'''
        pass

    def asGenericBool(self): 
        '''asGenericBool(self) -> bool


Returns the generic data represented by this handle in the data block.'''
        pass

    def asAddr(self): 
        '''asAddr(self) -> void*&


Returns the data represented by this handle in the data block.'''
        pass

    def setMDistance(self, val): 
        '''setMDistance(self, val)
Arguments:
	[in]	val = MDistance


Set the data that this handle represents in the data block.'''
        pass

    def asVector(self): 
        '''asVector(self) -> MVector


Returns the data represented by this handle in the data block.'''
        pass

    def setShort(self, val): 
        '''setShort(self, val)
Arguments:
	[in]	val = short


Set the data that this handle represents in the data block.'''
        pass

    def set2Float(self, val1, val2): 
        '''set2Float(self, val1, val2)
Arguments:
	[in]	val1 = float
	[in]	val2 = float


Set the data that this handle represents in the data block.'''
        pass

    def setGenericShort(self, value, force): 
        '''setGenericShort(self, value, force)
Arguments:
	[in]	value = short
	[in]	force = bool


Set the data that this handle represents in the data block.'''
        pass

    def asDistance(self): 
        '''asDistance(self) -> MDistance


Returns the data represented by this handle in the data block.'''
        pass

    def asGenericChar(self): 
        '''asGenericChar(self) -> char


Returns the generic data represented by this handle in the data block.'''
        pass

    def setMVector(self, val): 
        '''setMVector(self, val)
Arguments:
	[in]	val = MVector


Set the data that this handle represents in the data block.'''
        pass

    def setGenericBool(self, value, force): 
        '''setGenericBool(self, value, force)
Arguments:
	[in]	value = bool
	[in]	force = bool


Set the data that this handle represents in the data block.'''
        pass

    def acceptedTypeIds(self, typids): 
        '''acceptedTypeIds(self, typids)
Arguments:
	[out]	typids = MUintArray


This method returns an array of  MTypeId  ids that the data handle can accept. The  MTypeId  can be reconstructed using the unsigned int in id.'''
        pass

    def asNurbsSurfaceTransformed(self): 
        '''asNurbsSurfaceTransformed(self) -> MObject


Returns the data represented by this handle in the data block. The object returned by this call may be used directly with the nurbs surface function set ( MFnNurbsSurface ) or the nurbs surface CV iterator ( MItSurfaceCV ).'''
        pass

    def asUChar(self): 
        '''asUChar(self) -> char&


Returns the data represented by this handle in the data block.'''
        pass

    def setClean(self): 
        '''setClean(self)

Marks the data that is represented by this handle as being clean. This should be done after recalculating the data from the inputs. 
  Reprocessed example  
 Examples: 
 
   
 anisotropicShader.cpp ,  apiMeshShape.cpp ,  backfillShader.cpp ,  blindDataShader.cpp ,  buildRotationNode.cpp ,  cellShader.cpp ,  cgfxShaderNode.cpp ,  checkerShader.cpp ,  clearcoat.cpp ,  compositingShader.cpp ,  contrastShader.cpp ,  cvColorShader.cpp ,  displacementShader.cpp ,  flameShader.cpp ,  gammaShader.cpp ,  genericAttributeNode.cpp ,  geomShader.cpp ,  GLSLShaderNode.cpp ,  hwDecalBumpShader_NV20.cpp ,  hwPhongShader.cpp ,  hwReflectBumpShader_NV20.cpp ,  hwRefractReflectShader_NV20.cpp ,  hwToonShader_NV20.cpp ,  hwUnlitShader.cpp ,  interpShader.cpp ,  lambertShader.cpp ,  lavaShader.cpp ,  lightShader.cpp ,  meshOpNode.cpp ,  mixtureShader.cpp ,  noiseShader.cpp ,  phongShader.cpp ,  renderAccessNode.cpp ,  rockingTransform.cpp ,  shadowMatteShader.cpp ,  shiftNode.cpp ,  slopeShaderNode.cpp ,  solidCheckerShader.cpp ,  splitUVNode.cpp , and  volumeShader.cpp . 
 
'''
        pass

    def data(self): 
        '''data(self) -> MObject


Returns the data object from this handle. The object returned should be used with the appropriate data function set. This method is not valid for simple numeric types.'''
        pass

    def asNurbsSurface(self): 
        '''asNurbsSurface(self) -> MObject


Returns the data represented by this handle in the data block. The object returned by this call may be used directly with the nurbs surface function set and iterator. Even though this method does not return a reference to an  MObject , modifications to the  MObject  instance will update the contents of the handle in the data block. The method  MDataHandle::setClean  should be called after the data block has been modified.'''
        pass

    def setMPxData(self, data): 
        '''setMPxData(self, data)
Arguments:
	[in]	data = MPxData


Set the data that this handle represents in the data block. This method takes a pointer to a user defined data object. The data block will become the new owner of the data object that you pass in. Do not delete it.'''
        pass

    def setMFloatVector(self, val): 
        '''setMFloatVector(self, val)
Arguments:
	[in]	val = MFloatVector


Set the data that this handle represents in the data block.'''
        pass

    def asFloatVector(self): 
        '''asFloatVector(self) -> MFloatVector


Returns the data represented by this handle in the data block.'''
        pass

    def asBool(self): 
        '''asBool(self) -> bool&


Returns the data represented by this handle in the data block.'''
        pass

    def set3Int(self, val1, val2, val3): 
        '''set3Int(self, val1, val2, val3)
Arguments:
	[in]	val1 = int
	[in]	val2 = int
	[in]	val3 = int


Set the data that this handle represents in the data block.'''
        pass

    def setInt(self, val): 
        '''setInt(self, val)
Arguments:
	[in]	val = int


Set the data that this handle represents in the data block.'''
        pass

    def asFloatMatrix(self): 
        '''asFloatMatrix(self) -> MFloatMatrix


Returns the data represented by this handle in the data block. This method is only valid for attributes created using the  MFnMatrixAttribute  function set.'''
        pass

    def asGenericDouble(self): 
        '''asGenericDouble(self) -> double


Returns the generic data represented by this handle in the data block.'''
        pass

    def setGenericFloat(self, value, force): 
        '''setGenericFloat(self, value, force)
Arguments:
	[in]	value = float
	[in]	force = bool


Set the data that this handle represents in the data block.'''
        pass

    def asNurbsCurve(self): 
        '''asNurbsCurve(self) -> MObject


Returns the data represented by this handle in the data block. The object returned by this call may be used directly with the nurbs curve function set and iterator. Even though this method does not return a reference to an  MObject , modifications to the  MObject  instance will update the contents of the handle in the data block. The method  MDataHandle::setClean  should be called after the data block has been modified.'''
        pass

    def set3Double(self, val1, val2, val3): 
        '''set3Double(self, val1, val2, val3)
Arguments:
	[in]	val1 = double
	[in]	val2 = double
	[in]	val3 = double


Set the data that this handle represents in the data block.'''
        pass

    def asDouble(self): 
        '''asDouble(self) -> double&


Returns the data represented by this handle in the data block.'''
        pass

    def asShort2(self): 
        '''asShort2(self) -> short2&


Returns the data represented by this handle in the data block.'''
        pass

    def asShort3(self): 
        '''asShort3(self) -> short3&


Returns the data represented by this handle in the data block.'''
        pass

    def setFloat(self, val): 
        '''setFloat(self, val)
Arguments:
	[in]	val = float


Set the data that this handle represents in the data block.'''
        pass

    def asInt(self): 
        '''asInt(self) -> int&


Returns the data represented by this handle in the data block.'''
        pass

    def setGenericInt(self, value, force): 
        '''setGenericInt(self, value, force)
Arguments:
	[in]	value = int
	[in]	force = bool


Set the data that this handle represents in the data block.'''
        pass

class MDistance:
    '''Manipulate Linear Data. The MDistance class provides a fundamental type for the Maya API to hold and manipulate linear data. All API methods that require or return distance information do so through variables of this type. '''
    def __init__(self):
        pass


    def asMillimeters(self): 
        '''asMillimeters(self) -> double


Return the current value of this instance in millimeters.'''
        pass

    def asMiles(self): 
        '''asMiles(self) -> double


Return the current value of this instance in miles.'''
        pass

    def asFeet(self): 
        '''asFeet(self) -> double


Return the current value of this instance in feet.'''
        pass

    def setValue(self, newValue): 
        '''setValue(self, newValue)
Arguments:
	[in]	newValue = double


Set the value of this instance'''
        pass

    def asYards(self): 
        '''asYards(self) -> double


Return the current value of this instance in yards.'''
        pass

    def uiUnit(self): 
        '''uiUnit(self) -> MDistance.Unit


Returns the Working Units (or UI units) chosen in the settings of the prefs window.'''
        pass

    def asKilometers(self): 
        '''asKilometers(self) -> double


Return the current value of this instance in kilometers.'''
        pass

    def asMeters(self): 
        '''asMeters(self) -> double


Return the current value of this instance in meters.'''
        pass

    def asCentimeters(self): 
        '''asCentimeters(self) -> double


Return the current value of this instance in centimeters.'''
        pass

    def value(self): 
        '''value(self) -> double


Return the value of the current instance in the currently set units.'''
        pass

    def as(self, otherUnit): 
        '''as(self, otherUnit) -> double
Returns: The current value in the given units

Arguments:
	[in]	otherUnit = MDistance.Unit


Return the current value of this instance in the provided units.'''
        pass

    def kMeters(self):
        '''This is an enum of Unit.
Description: Meters.
Value: 8'''
        pass

    def kMillimeters(self):
        '''This is an enum of Unit.
Description: Millimeters.
Value: 5'''
        pass

    def kYards(self):
        '''This is an enum of Unit.
Description: Yards.
Value: 3'''
        pass

    def kKilometers(self):
        '''This is an enum of Unit.
Description: Kilometers.
Value: 7'''
        pass

    def kFeet(self):
        '''This is an enum of Unit.
Description: Feet.
Value: 2'''
        pass

    def kCentimeters(self):
        '''This is an enum of Unit.
Description: Centimeters.
Value: 6'''
        pass

    def kInches(self):
        '''This is an enum of Unit.
Description: Inches.
Value: 1'''
        pass

    def kMiles(self):
        '''This is an enum of Unit.
Description: Miles.
Value: 4'''
        pass

    class Unit:
        '''Non-functional class.  Values for this enum:
        kMeters
        kMillimeters
        kYards
        kKilometers
        kFeet
        kCentimeters
        kInches
        kMiles
'''
        def __init__(self):
            pass

    def uiToInternal(self, uiValue): 
        '''uiToInternal(self, uiValue) -> double
Returns: The value in internal units. 

Arguments:
	[in]	uiValue = double


Converts a value from UI units to internal units.'''
        pass

    def asInches(self): 
        '''asInches(self) -> double


Return the current value of this instance in inches.'''
        pass

    def internalUnit(self): 
        '''internalUnit(self) -> MDistance.Unit


Returns the internal unit system.'''
        pass

    def internalToUI(self, internalValue): 
        '''internalToUI(self, internalValue) -> double
Returns: The value in UI units 

Arguments:
	[in]	internalValue = double


Converts a value from internal units to UI units.'''
        pass

    def setUnit(self, newUnit): 
        '''setUnit(self, newUnit)
Arguments:
	[in]	newUnit = MDistance.Unit


Set the units used by this instance.'''
        pass

    def unit(self): 
        '''unit(self) -> MDistance.Unit


Return the units currently in effect for this instance.'''
        pass

    def setUIUnit(self, newUnit): 
        '''setUIUnit(self, newUnit)
Arguments:
	[in]	newUnit = MDistance.Unit


Set the unit system to be used by the user in the UI.'''
        pass

class MDoubleArray:
    '''Array of doubles data type. This class implements an array of doubles. Common convenience functions are available, and the implementation is compatible with the internal Maya implementation so that it can be passed efficiently between plugins and internal maya data structures.Methods that query the array are threadsafe. Writing to different array elements at the same time with the set() method is threadsafe. Methods that modify the array length, namely append(), insert(), remove() and setLength() are not threadsafe. '''
    def __init__(self):
        pass


    def insert(self, element, index): 
        '''insert(self, element, index)
Arguments:
	[in]	element = double
	[in]	index = int


Inserts a new value into the array at the given index. The initial element at that index, and all following elements, are shifted towards the last. If the array cannot be expanded in size by 1 element, then the insert will fail and the existing array will remain unchanged.'''
        pass

    def set(self, element, index): 
        '''set(self, element, index)
Arguments:
	[in]	element = float
	[in]	index = int


Sets the value of the indicated element to the indicated float value.'''
        pass

    def get(self, array): 
        '''get(self, array)
Arguments:
	[out]	array = float


Copy the elements of the array into the given C++ array of floats. No checking is done to ensure that the destination C++ array of floats is large enough to hold all the elements of the instance.'''
        pass

    def clear(self): 
        '''clear(self)
'''
        pass

    def sizeIncrement(self): 
        '''sizeIncrement(self) -> int


Return the size by which the array will be expanded whenever expansion is necessary.'''
        pass

    def remove(self, index): 
        '''remove(self, index)
Arguments:
	[in]	index = int


Remove the array element at the given index. All array elements following the removed element are shifted toward the first element.'''
        pass

    def length(self): 
        '''length(self) -> int


Returns the number of elements in the instance.'''
        pass

    def setSizeIncrement(self, newIncrement): 
        '''setSizeIncrement(self, newIncrement)
Arguments:
	[in]	newIncrement = int


Set the size by which the array will be expanded whenever expansion is necessary.'''
        pass

    def copy(self, source): 
        '''copy(self, source)
Arguments:
	[in]	source = MDoubleArray


Copy the contents of the source array to this array.'''
        pass

    def setLength(self, length): 
        '''setLength(self, length)
Arguments:
	[in]	length = int


Set the length of the array. This will grow and shrink the array as desired. Elements that are grown have uninitialized values, while those which are shrunk will lose the data contained in the deleted elements (ie. it will release the memory).'''
        pass

    def append(self, element): 
        '''append(self, element)
Arguments:
	[in]	element = double


Adds a new element to the end of the array. If the array cannot be expanded in size by 1 element, then the append will fail and the existing array will remain unchanged.'''
        pass

class MDGContext:
    '''Dependency graph (DG) context class. Control the way in which dependency nodes are evaluated.DG contexts are used to define the way in which a dependency node is going to be evaluated. Examples of such contexts include "normal", "at a given time, "for a specific instance", etc.MDGContext is mainly used in two places; within methods that trigger evaluations, to define what kind of evaluate is being requested, and within data blocks (MDataBlock), to identify how the data was created. '''
    def __init__(self):
        pass


    def getTime(self, timeVal): 
        '''getTime(self, timeVal)
Arguments:
	[out]	timeVal = MTime


Return the single time for which this context is valid. The context must be a timed context, i.e. not a normal one.'''
        pass

    def isNormal(self): 
        '''isNormal(self) -> bool
Returns: true this context is normal 
false this context is not normal


Determines if this context is that of "normal" evaluation.'''
        pass

class MDGMessage:
    '''Dependency graph messages. This class is used to register callbacks for dependency graph messages.There are 4 add callback methods which will add callbacks for the following messagesA filter can be specified for node added/removed messages. The default node type is "dependNode" which matches all nodes. Each method returns an id which is used to remove the callback.To remove a callback use MMessage::removeCallback. All callbacks that are registered by a plug-in must be removed by that plug-in when it is unloaded. Failure to do so will result in a fatal error. '''
    def __init__(self):
        pass


    def addNodeRemovedCallback(self, func, nodeType, clientData): 
        '''addNodeRemovedCallback(self, func, nodeType, clientData) -> MCallbackId

Arguments:
	[in]	func = MMessage.MNodeFunction
	[in]	nodeType = MString
	[in]	clientData = void


NodeRemoved callback. 
'''
        pass

    def addConnectionCallback(self, func, clientData): 
        '''addConnectionCallback(self, func, clientData) -> MCallbackId

Arguments:
	[in]	func = MMessage.MPlugFunction
	[in]	clientData = void


Connection callback. 
'''
        pass

    def addNodeAddedCallback(self, func, nodeType, clientData): 
        '''addNodeAddedCallback(self, func, nodeType, clientData) -> MCallbackId

Arguments:
	[in]	func = MMessage.MNodeFunction
	[in]	nodeType = MString
	[in]	clientData = void


NodeAdded callback. 
'''
        pass

    def addForceUpdateCallback(self, func, clientData): 
        '''addForceUpdateCallback(self, func, clientData) -> MCallbackId

Arguments:
	[in]	func = MMessage.MTimeFunction
	[in]	clientData = void


ForceUpdate callback. 
'''
        pass

    def addPreConnectionCallback(self, func, clientData): 
        '''addPreConnectionCallback(self, func, clientData) -> MCallbackId

Arguments:
	[in]	func = MMessage.MPlugFunction
	[in]	clientData = void


Pre-Connection callback. 
'''
        pass

    def addTimeChangeCallback(self, func, clientData): 
        '''addTimeChangeCallback(self, func, clientData) -> MCallbackId

Arguments:
	[in]	func = MMessage.MTimeFunction
	[in]	clientData = void


TimeChange callback. 
'''
        pass

class MDGModifier:
    '''Dependency graph modifier. An MDGModifier is used to change the structure of the dependency graph. This includes adding nodes, making new connections, and removing existing connections. To perform operations using an MDGModifier, register all of the changes that are to be made and then call the doIt method to make the changes. Undo is provided through the undoIt method.Under some situations, a doIt() call may be required to separate some of the operations. The specific case of interest involves performing a disconnect() and a deleteNode() on the same node within the stack of operations.Assuming that the Maya model has a connected node that was going to be deleted, do the following:Then undoIt() can be implemented as:'''
    def __init__(self):
        pass


    def doIt(self): 
        '''doIt(self)

Executes all of the operations that have been given to this modifier. It is only valid to call this method after all of the operations have been specified. This method may also be called after undoIt to redo the operations.'''
        pass

    def deleteNode(self, node): 
        '''deleteNode(self, node)
Arguments:
	[in]	node = MObject


This method adds an operation to this dependency graph modifier that will delete a dependency graph node from the dependency graph.'''
        pass

    def disconnect(self, source, dest): 
        '''disconnect(self, source, dest)
Arguments:
	[in]	source = MPlug
	[in]	dest = MPlug


Adds an operation to this dependency graph modifier that disconnects two plugs in the dependency graph.'''
        pass

    def removeAttribute(self, node, attribute, type): 
        '''removeAttribute(self, node, attribute, type)
Arguments:
	[in]	node = MObject
	[in]	attribute = MObject
	[in]	type = MFnDependencyNode.MAttrClass


Removes a dynamic attribute from the given dependency node.'''
        pass

    def createNode(self, type): 
        '''createNode(self, type) -> MObject
Returns: A handle for the new node

Arguments:
	[in]	type = MString


This method adds an operation to this dependency graph modifier that will add a new dependency graph node of the given type to the dependency graph. This method may not be used to construct new DAG nodes. Use  MDagModifier  for that purpose.'''
        pass

    def setNodeLockState(self, node, newState): 
        '''setNodeLockState(self, node, newState)
Arguments:
	[in]	node = MObject
	[in]	newState = bool


This method adds an operation to this dependency graph modifier that will set the lock state of the node.'''
        pass

    def addAttribute(self, node, attribute, type): 
        '''addAttribute(self, node, attribute, type)
Arguments:
	[in]	node = MObject
	[in]	attribute = MObject
	[in]	type = MFnDependencyNode.MAttrClass


Add a new dynamic attribute to the given dependency node. The  type  parameter allows the attribute to be added to a particular node, or the whole class of nodes.'''
        pass

    def renameNode(self, node, newName): 
        '''renameNode(self, node, newName)
Arguments:
	[in]	node = MObject
	[in]	newName = MString


This method adds an operation to this dependency graph modifier that will rename a dependency graph node.'''
        pass

    def newPlugValue(self, plug, plugValue): 
        '''newPlugValue(self, plug, plugValue)
Arguments:
	[in]	plug = MPlug
	[in]	plugValue = MObject


Adds an operation to this dependency graph modifier that sets a plug value. Plug values can be created with the  MFnNumericData  class.'''
        pass

    def connect(self, source, dest): 
        '''connect(self, source, dest)
Arguments:
	[in]	source = MPlug
	[in]	dest = MPlug


Adds an operation to this dependency graph modifier that connects two plugs in the dependency graph. The value of the destination plug is supplied by the value of the source plug once they are connected.'''
        pass

    def undoIt(self): 
        '''undoIt(self)

Undoes all of the operations that have been given to this modifier. It is only valid to call this method after the doIt method has been called.'''
        pass

    def commandToExecute(self, command): 
        '''commandToExecute(self, command)
Arguments:
	[in]	command = MString


Adds an operation to this dependency graph modifier that executes a MEL command. The specified command must be undoable otherwise unexepected results may occur.'''
        pass

class MEulerRotation:
    '''Euler Rotation Math. This class provides methods for working with euler angle rotations. Euler angles are described by rotations in radians around the x, y, and z axes, and the order in which those rotations occur. '''
    def __init__(self):
        pass


    identity = ''
    '''The euler rotation identity. The rotation order is XYZ. '''

    def asQuaternion(self): 
        '''asQuaternion(self) -> MQuaternion


Converts an euler rotation to a quaternion.'''
        pass

    def bound(self): 
        '''bound(self) -> MEulerRotation


Returns the result of bounding this rotation to be within +/- PI. Bounding a rotation to be within +/- PI is defined to be the result of offsetting the rotation by +/- 2nPI (term by term) such that the offset is within +/- PI.'''
        pass

    def __radd__(self, other): 
        '''__radd__(self, other) -> MEulerRotation
Returns: A reference the euler rotation which has been added to the other euler rotation 

Arguments:
	[in]	other = MEulerRotation


The in place euler rotation addition operator.'''
        pass

    def __rsub__(self, other): 
        '''__rsub__(self, other) -> MEulerRotation
Returns: A reference the euler rotation which has had the other euler rotation subtracted from it 

Arguments:
	[in]	other = MEulerRotation


The in place euler rotation subtraction operator.'''
        pass

    def reorderIt(self, ord): 
        '''reorderIt(self, ord) -> MEulerRotation
Returns: A reference to the euler rotation that has been reordered 

Arguments:
	[in]	ord = MEulerRotation.RotationOrder


Performs an in place reordering of this euler rotation, such that the euler rotation will have the specified rotation order.'''
        pass

    def __neq__(self, other): 
        '''__neq__(self, other) -> bool
Returns: true the euler rotations are not identical 
false the euler rotations are identical 

Arguments:
	[in]	other = MEulerRotation


The euler rotation inequality operator.'''
        pass

    def closestCut(self, dst): 
        '''closestCut(self, dst) -> MEulerRotation
Returns: The closest cut of this rotation 

Arguments:
	[in]	dst = MEulerRotation


Returns the closest cut of this rotation to "dst". The closest cut of rotation A to rotation B is defined to be the rotation that is +/- 2nPI to rotation A (term by term) and within +/- PI to rotation B.'''
        pass

    def inverse(self): 
        '''inverse(self) -> MEulerRotation


Returns the inverse of this euler rotation. The rotation order will be reversed.'''
        pass

    def incrementalRotateBy(self, axis, angle): 
        '''incrementalRotateBy(self, axis, angle) -> MEulerRotation
Returns: A reference to the euler rotation that has been incrementally rotated 

Arguments:
	[in]	axis = MVector
	[in]	angle = double


Perform an incremental rotation by the specified axis and angle. The rotation is broken down and performed in smaller steps so that the angles update properly.'''
        pass

    def setToAlternateSolution(self): 
        '''setToAlternateSolution(self) -> MEulerRotation


Sets this euler rotation to an alternate solution of this rotation. The resulting rotation will be bound between +/- PI, and the rotation order will remain unchanged.'''
        pass

    def isZero(self, tolerance): 
        '''isZero(self, tolerance) -> bool
Returns: true the rotation is zero 
false the rotation is not zero 

Arguments:
	[in]	tolerance = double


This method returns true if this euler rotation is zero, within some given tolerance.'''
        pass

    def asMatrix(self): 
        '''asMatrix(self) -> MMatrix


Converts an euler rotation to a rotation matrix.'''
        pass

    def reorder(self, ord): 
        '''reorder(self, ord) -> MEulerRotation
Returns: Euler rotation that is the reordering of this euler rotation 

Arguments:
	[in]	ord = MEulerRotation.RotationOrder


Returns the reordering of this euler rotation, such that the euler rotation will have the specified rotation order.'''
        pass

    def boundIt(self): 
        '''boundIt(self) -> MEulerRotation


Bounds this rotation to be within +/- PI. Bounding a rotation to be within +/- PI is defined to be the result of offsetting the rotation by +/- 2nPI (term by term) such that the offset is within +/- PI.'''
        pass

    def setValue(self, xx, yy, zz, ord): 
        '''setValue(self, xx, yy, zz, ord) -> MEulerRotation
Returns: A reference to the euler rotation whose value has been set 

Arguments:
	[in]	xx = double
	[in]	yy = double
	[in]	zz = double
	[in]	ord = MEulerRotation.RotationOrder


Sets the euler rotation to the x, y, and z rotation components with the specified rotation order.'''
        pass

    def __getitem__(self, i): 
        '''__getitem__(self, i) -> double
Returns: The component of the euler rotation corresponding to the index 

Arguments:
	[in]	i = int


The index operator. If its argument is 0 it will return the x component of the euler rotation. If its argument is 1 it will return the y component of the euler rotation. If its argument is 2 it will return the z component of the euler rotation.'''
        pass

    def asVector(self): 
        '''asVector(self) -> MVector


Converts an euler rotation to a vector. The rotation order component is dropped.'''
        pass

    def isEquivalent(self, other, tolerance): 
        '''isEquivalent(self, other, tolerance) -> bool
Returns: true the euler rotations are equivalent 
false the euler rotations are not equivalent 

Arguments:
	[in]	other = MEulerRotation
	[in]	tolerance = double


This method returns true if this euler rotation is equivalent, within some given tolerance, to the other euler rotation.'''
        pass

    def __add__(self, other): 
        '''__add__(self, other) -> MEulerRotation
Returns: The sum of the two euler rotations 

Arguments:
	[in]	other = MEulerRotation


The euler rotation addition operator.'''
        pass

    def setToClosestSolution(self, dst): 
        '''setToClosestSolution(self, dst) -> MEulerRotation
Returns: A reference to the euler rotation that has been set to the closest solution 

Arguments:
	[in]	dst = MEulerRotation


Sets this euler rotation to the euler rotation that is the closest solution to the "dst" euler rotation.'''
        pass

    def invertIt(self): 
        '''invertIt(self) -> MEulerRotation


Performs an in place inversion of this euler rotation. The rotation order will be reversed.'''
        pass

    def __eq__(self, other): 
        '''__eq__(self, other) -> bool
Returns: true the euler rotations are identical 
false the euler rotations are not identical 

Arguments:
	[in]	other = MEulerRotation


The euler rotation equality operator.'''
        pass

    def alternateSolution(self): 
        '''alternateSolution(self) -> MEulerRotation


Returns an alternate solution to this rotation. The resulting rotation will be bound between +/- PI, and the rotation order will remain unchanged.'''
        pass

    def closestSolution(self, dst): 
        '''closestSolution(self, dst) -> MEulerRotation
Returns: The closest solution to the "dst" rotation 

Arguments:
	[in]	dst = MEulerRotation


Returns the euler rotation that is the closest solution to the "dst" euler rotation.'''
        pass

    def kZYX(self):
        '''This is an enum of RotationOrder.
Description: 
Value: 5'''
        pass

    def kZXY(self):
        '''This is an enum of RotationOrder.
Description: 
Value: 2'''
        pass

    def kXYZ(self):
        '''This is an enum of RotationOrder.
Description: 
Value: 0'''
        pass

    def kYZX(self):
        '''This is an enum of RotationOrder.
Description: 
Value: 1'''
        pass

    def kYXZ(self):
        '''This is an enum of RotationOrder.
Description: 
Value: 4'''
        pass

    def kXZY(self):
        '''This is an enum of RotationOrder.
Description: 
Value: 3'''
        pass

    class RotationOrder:
        '''Non-functional class.  Values for this enum:
        kZYX
        kZXY
        kXYZ
        kYZX
        kYXZ
        kXZY
'''
        def __init__(self):
            pass

    def __rmult__(self, other): 
        '''__rmult__(self, other) -> MEulerRotation
Returns: A reference to the euler rotation which has been multiplied with the double 

Arguments:
	[in]	other = double


The in place scalar multiplication operator.'''
        pass

    def setToClosestCut(self, dst): 
        '''setToClosestCut(self, dst) -> MEulerRotation
Returns: A reference to the euler rotation that has been set to the closest cut 

Arguments:
	[in]	dst = MEulerRotation


Sets this rotation to be the closest cut to "dst". The closest cut of rotation A to rotation B is defined to be the rotation that is +/- 2nPI to rotation A (term by term) and within +/- PI to rotation B.'''
        pass

    def __mul__(self, other): 
        '''__mul__(self, other) -> MEulerRotation
Returns: The product of the euler rotation and the scalar value 

Arguments:
	[in]	other = double


This scalar multiplication operator.'''
        pass

    def __sub__(self): 
        '''__sub__(self) -> MEulerRotation


The unary minus operator. Negates the value of each of the x, y, and z components of the euler rotation. The order remains the same.'''
        pass

    def decompose(self, matrix, ord): 
        '''decompose(self, matrix, ord) -> MEulerRotation
Returns: The euler rotation that has been decomposed from the rotation matrix 

Arguments:
	[in]	matrix = MMatrix
	[in]	ord = MEulerRotation.RotationOrder


Decompose a rotation matrix into the desired euler angles with the specified order.'''
        pass

class MEventMessage:
    '''Event messages. This class is used to register callbacks for specific events.The first parameter passed to the add callback method is the name of the event that will trigger the callback. The list of available event names can be retrieved by calling the getEventNames method or by using the -listEvents flag on the scriptJob command.The add callback method returns an id which is used to remove the callback.To remove a callback use MMessage::removeCallback.All callbacks that are registered by a plug-in must be removed by that plug-in when it is unloaded. Failure to do so will result in a fatal error. '''
    def __init__(self):
        pass


    def getEventNames(self, names): 
        '''getEventNames(self, names)
Arguments:
	[out]	names = MStringArray


This method returns the list of available event names.'''
        pass

    def addEventCallback(self, eventName, func, clientData): 
        '''addEventCallback(self, eventName, func, clientData) -> MCallbackId

Arguments:
	[in]	eventName = MString
	[in]	func = MMessage.MBasicFunction
	[in]	clientData = void


This method registers a callback for event occurred messages.'''
        pass

class MFileIO:
    '''I/O operations on scene files. Methods for opening, saving, importing, exporting and referencing files.The MFileIO class provides a set of global functions that can be used to load and store scene elements into maya files. Methods are also provided to import elements from other files into the current scene, and export elements of the current scene into files. As well, references to other files can be created and removed.This class implements only the most common operations from the full set possible with the MEL command "file." See the documentation of this command for a complete listing of all the possiblities. If more control is required than provided by this class, a MEL command can be constructed according to the instructions for the "file" command, and issued via the executeCommand method of the MGlobal class. '''
    def __init__(self):
        pass


    def fileCurrentlyLoading(self): 
        '''fileCurrentlyLoading(self) -> MString


Return the name of the file currently being loaded.'''
        pass

    def getErrorStatus(self): 
        '''getErrorStatus(self) -> bool
Returns: Boolean value indicating the error status.


Returns the error status of the last file read. Returns true if any error occurred during the last file read, else false is returned.'''
        pass

    def importFile(self, fileName, type, preserveReferences, nameSpace): 
        '''importFile(self, fileName, type, preserveReferences, nameSpace)
Arguments:
	[in]	fileName = MString
	[in]	type = char
	[in]	preserveReferences = bool
	[in]	nameSpace = char


Import the scene elements from the given file into the current scene. This operation is similar to open, but instead of replacing the current scene with the one from the new file, it adds the elements from that file to the existing ones in the current scene.'''
        pass

    def beforeOpenFilename(self): 
        '''beforeOpenFilename(self) -> MString
Returns: The name of the file to be opened


Retrieves the name of the file requested to be opened. This name can be retrieved from within the beforeOpenCheck and beforeOpen callback functions (that must be registered using  MSceneMessage::addCallback()  before the file is attempted to be opened). If called outside of these two callback functions the results are undefined.'''
        pass

    def reference(self, fileName, deferReference, lockReference): 
        '''reference(self, fileName, deferReference, lockReference)
Arguments:
	[in]	fileName = MString
	[in]	deferReference = bool
	[in]	lockReference = bool


Add the given filename as a reference from the current file. When a new file is opened, the contents of any files it references are read into the scene, however maya remembers that the elements came from the referenced file, and does not write them during a save operation. Instead the reference is written so the contents of the references file (which might have changed) will be read again when the scene is reloaded.'''
        pass

    def setCurrentFile(self, fileName): 
        '''setCurrentFile(self, fileName)
Arguments:
	[in]	fileName = MString


Set the value of the current active file.'''
        pass

    def beforeImportFilename(self): 
        '''beforeImportFilename(self) -> MString
Returns: The name of the file to be imported


Retrieves the name of the file requested to be imported. This name can be retrieved from within the beforeImportCheck and beforeImport callback functions (that must be registered using  MSceneMessage::addCallback()  before the file is attempted to be imported). If called outside of these two callback functions the results are undefined.'''
        pass

    def isReadingFile(self): 
        '''isReadingFile(self) -> bool


Determine if Maya is currently in the middle of a file read operation.'''
        pass

    def cleanReference(self, referenceNodeName, editCommand): 
        '''cleanReference(self, referenceNodeName, editCommand)
Arguments:
	[in]	referenceNodeName = MString
	[in]	editCommand = char


This function removes the edits from the passed in reference node. The reference must be in an unloaded state.'''
        pass

    def loadReferenceByNode(self, referenceNode): 
        '''loadReferenceByNode(self, referenceNode) -> MString
Returns: The name of the loaded reference file

Arguments:
	[in]	referenceNode = MObject


Loads the reference, referenced by the given reference node object.'''
        pass

    def isImportingFile(self): 
        '''isImportingFile(self) -> bool


Determine if Maya is currently in the middle of a file import operation.'''
        pass

    def isWritingFile(self): 
        '''isWritingFile(self) -> bool


Determine if Maya is currently in the middle of a file write operation.'''
        pass

    def exportAsReference(self, fileName, type): 
        '''exportAsReference(self, fileName, type)
Arguments:
	[in]	fileName = MString
	[in]	type = char


Export the selected objects into a reference file.'''
        pass

    def mustRenameToSaveMsg(self): 
        '''mustRenameToSaveMsg(self) -> MString
Returns: The error message to display.


This method returns a string that is displayed when a user attempts to save a scene that was set to not overwrite itself. See the  MFileIO::setMustRenameToSave()  documentation.'''
        pass

    def exportSelectedAnimFromReference(self, fileName, refNodeName, type): 
        '''exportSelectedAnimFromReference(self, fileName, refNodeName, type)
Arguments:
	[in]	fileName = MString
	[in]	refNodeName = MString
	[in]	type = char


Export the selected animation from reference, to the specified file.'''
        pass

    def beforeSaveUserFileTranslator(self): 
        '''beforeSaveUserFileTranslator(self) -> MPxFileTranslator
Returns: A pointer to the file translator being used for file save, or NULL.


Retrieves the plug-in-defined file translator being used for file save, if any. If a standard Maya file translator (e.g. mayaAscii) is being used, returns NULL. The translator can be retrieved from within the beforeSaveCheck and beforeSave callback functions (that must be registered using  MSceneMessage::addCallback()  before the file is attempted to be saved). If called outside of these two callback functions the results are undefined.'''
        pass

    def getFileTypes(self, types): 
        '''getFileTypes(self, types)
Arguments:
	[out]	types = MStringArray


Returns an array of all the valid type names that Maya currently supports. Only elements from this list are valid arguments for the  type  arguments to  open ,  saveAs ,  import ,  exportSelected , and  exportAll .'''
        pass

    def isNewingFile(self): 
        '''isNewingFile(self) -> bool


Determine if Maya is currently performing a "new" operation.'''
        pass

    def open(self, fileName, type, force, refMode, ignoreVersion): 
        '''open(self, fileName, type, force, refMode, ignoreVersion)
Arguments:
	[in]	fileName = MString
	[in]	type = char
	[in]	force = bool
	[in]	refMode = MFileIO.ReferenceMode
	[in]	ignoreVersion = bool


Open the given file, and set the current active file to this file. If there are unsaved changes in the current scene, this operation will fail unless the force flag is set to true.'''
        pass

    def fileType(self): 
        '''fileType(self) -> MString


Return the type of the current active file.'''
        pass

    def getLastTempFile(self): 
        '''getLastTempFile(self) -> MString
Returns: The name of the temp file


Returns the temp file used during file save.'''
        pass

    def getReferenceConnectionsBroken(self, node, append, removeDuplicates, srcPlugs, destPlugs): 
        '''getReferenceConnectionsBroken(self, node, append, removeDuplicates, srcPlugs, destPlugs)
Arguments:
	[in]	node = MObject
	[out]	srcPlugs = MPlugArray
	[out]	destPlugs = MPlugArray
	[in]	append = bool
	[in]	removeDuplicates = bool


Returns arrays of source and destination plugs corresponding to the broken connections from referenced files, where those connections involved the specified node.'''
        pass

    def saveReference(self, referenceFileName): 
        '''saveReference(self, referenceFileName)
Arguments:
	[in]	referenceFileName = MString


This function saves reference node edits and connections to reference file'''
        pass

    def loadReference(self, referenceFileName): 
        '''loadReference(self, referenceFileName) -> MString
Returns: The name of the loaded reference file

Arguments:
	[in]	referenceFileName = MString


Loads the reference, referenced by the given reference node name and file name.'''
        pass

    def unloadReference(self, referenceFileName): 
        '''unloadReference(self, referenceFileName) -> MString
Returns: The name of the unloaded reference file

Arguments:
	[in]	referenceFileName = MString


Unloads the reference, referenced by the given reference node and file.'''
        pass

    def save(self, force): 
        '''save(self, force)
Arguments:
	[in]	force = bool


Save the contents of the current scene to the currently active file. If there have been no changes to the scene since the last save, then this operation will succeed, but not actually rewrite the save file unless the force flag is set to true.'''
        pass

    def beforeImportUserFileTranslator(self): 
        '''beforeImportUserFileTranslator(self) -> MPxFileTranslator
Returns: A pointer to the file translator being used to import, or NULL.


Retrieves the plug-in-defined file translator being used for import, if any. If a standard Maya file translator (e.g. mayaAscii) is being used, returns NULL. The translator can be retrieved from within the beforeImportCheck and beforeImport callback functions (that must be registered using  MSceneMessage::addCallback()  before the file is attempted to be imported). If called outside of these two callback functions the results are undefined.'''
        pass

    def exportAnim(self, fileName, type): 
        '''exportAnim(self, fileName, type)
Arguments:
	[in]	fileName = MString
	[in]	type = char


Export animation to the specified file.'''
        pass

    def beforeReferenceFilename(self): 
        '''beforeReferenceFilename(self) -> MString
Returns: The name of the file to be referenced


Retrieves the name of the file requested to be referenced. This name can be retrieved from within the beforeRefenceCheck and beforeRefence callback functions (that must be registered using  MSceneMessage::addCallback()  before the file is attempted to be referenced). If called outside of these two callback functions the results are undefined.'''
        pass

    def saveAs(self, fileName, type, force): 
        '''saveAs(self, fileName, type, force)
Arguments:
	[in]	fileName = MString
	[in]	type = char
	[in]	force = bool


Save the contents of the current scene to the given file. If there have been no changes to the scene since the last save, then this operation will succeed, but not actually rewrite the save file unless the force flag is set to true.'''
        pass

    def isOpeningFile(self): 
        '''isOpeningFile(self) -> bool


Determine if Maya is currently performing a file open operation.'''
        pass

    def beforeExportFilename(self): 
        '''beforeExportFilename(self) -> MString
Returns: The name of the file to be exported


Retrieves the name of the file requested to be exported. This name can be retrieved from within the beforeExportCheck and beforeExport callback functions (that must be registered using  MSceneMessage::addCallback()  before the file is attempted to be exported). If called outside of these two callback functions the results are undefined.'''
        pass

    def mustRenameToSave(self): 
        '''mustRenameToSave(self) -> bool
Returns: true if this file must be renamed before saving.


Scenes may be flagged as needing to be renamed before saving. The purpose is to prevent overwriting the original file, which may have had a significant change. Users will need to use save as to save the scene with a different file name.'''
        pass

    def getReferences(self, references): 
        '''getReferences(self, references)
Arguments:
	[out]	references = MStringArray


Return an array of all the files referenced from the currently active file.'''
        pass

    def beforeOpenUserFileTranslator(self): 
        '''beforeOpenUserFileTranslator(self) -> MPxFileTranslator
Returns: A pointer to the file translator being used for file open, or NULL.


Retrieves the plug-in-defined file translator being used for file open, if any. If a standard Maya file translator (e.g. mayaAscii) is being used, returns NULL. The translator can be retrieved from within the beforeOpenCheck and beforeOpen callback functions (that must be registered using  MSceneMessage::addCallback()  before the file is attempted to be opened). If called outside of these two callback functions the results are undefined.'''
        pass

    def kLoadAllReferences(self):
        '''This is an enum of ReferenceMode.
Description: Load all references in the scene.
Value: 1'''
        pass

    def kLoadNoReferences(self):
        '''This is an enum of ReferenceMode.
Description: Don't load any references.
Value: 2'''
        pass

    def kLoadDefault(self):
        '''This is an enum of ReferenceMode.
Description: Load references that were loaded when scene was saved.
Value: 0'''
        pass

    class ReferenceMode:
        '''Non-functional class.  Values for this enum:
        kLoadAllReferences
        kLoadNoReferences
        kLoadDefault
'''
        def __init__(self):
            pass

    def getReferenceConnectionsMade(self, fileName, connections): 
        '''getReferenceConnectionsMade(self, fileName, connections)
Arguments:
	[in]	fileName = MString
	[out]	connections = MStringArray


Return an array of attribute pairs representing connections made to nodes in the given referenced file. The first element of the pair is the source attribute in the connection, and the second is the destination. These pairs correspond to the "connectAttr" statements in a scene file where changes to the referenced file occur after the referenced file has been opened.'''
        pass

    def getReferenceNodes(self, fileName, nodes): 
        '''getReferenceNodes(self, fileName, nodes)
Arguments:
	[in]	fileName = MString
	[out]	nodes = MStringArray


Return an array of all the nodes referenced by the given filename.'''
        pass

    def beforeExportUserFileTranslator(self): 
        '''beforeExportUserFileTranslator(self) -> MPxFileTranslator
Returns: A pointer to the file translator being used to export, or NULL.


Retrieves the plug-in-defined file translator being used for export, if any. If a standard Maya file translator (e.g. mayaAscii) is being used, returns NULL. The translator can be retrieved from within the beforeExportCheck and beforeExport callback functions (that must be registered using  MSceneMessage::addCallback()  before the file is attempted to be exported). If called outside of these two callback functions the results are undefined.'''
        pass

    def setMustRenameToSaveMsg(self, errorMsg): 
        '''setMustRenameToSaveMsg(self, errorMsg)
Arguments:
	[in]	errorMsg = MString


This method sets a string that is displayed when a user attempts to save a scene that was set to not overwrite itself. See the  MFileIO::setMustRenameToSave()  documentation.'''
        pass

    def currentFile(self): 
        '''currentFile(self) -> MString


Return the name of the currently active file.'''
        pass

    def exportSelected(self, fileName, type, preserveReferences): 
        '''exportSelected(self, fileName, type, preserveReferences)
Arguments:
	[in]	fileName = MString
	[in]	type = char
	[in]	preserveReferences = bool


Export all currently selected scene elements to the given file.'''
        pass

    def getReferenceFileByNode(self, referenceNode): 
        '''getReferenceFileByNode(self, referenceNode) -> MString
Returns: The name of the reference file, containing the given node.

Arguments:
	[in]	referenceNode = MObject


Returns the name of the reference file, which contains the given reference node.'''
        pass

    def setMustRenameToSave(self, rename): 
        '''setMustRenameToSave(self, rename)
Arguments:
	[in]	rename = bool


This method enabled or disables a state where the current Maya scene must save to a different file name. This can be used to prevent a user from overwriting the original scene if a particularly dangerous or experimental change was made.'''
        pass

    def exportAnimFromReference(self, fileName, refNodeName, type): 
        '''exportAnimFromReference(self, fileName, refNodeName, type)
Arguments:
	[in]	fileName = MString
	[in]	refNodeName = MString
	[in]	type = char


Export the animation from the specified reference node, to the specified file.'''
        pass

    def exportSelectedAnim(self, fileName, type): 
        '''exportSelectedAnim(self, fileName, type)
Arguments:
	[in]	fileName = MString
	[in]	type = char


Export selected animation to the specified file.'''
        pass

    def beforeSaveFilename(self): 
        '''beforeSaveFilename(self) -> MString
Returns: The name of the file to be saved


Retrieves the name of the file requested to be saved. This name can be retrieved from within the beforeSaveCheck and beforeSave callback functions (that must be registered using  MSceneMessage::addCallback()  before the file is attempted to be saved). If called outside of these two callback functions the results are undefined.'''
        pass

    def removeReference(self, fileName): 
        '''removeReference(self, fileName)
Arguments:
	[in]	fileName = MString


Remove the named file as a reference from the current file.'''
        pass

    def newFile(self, force): 
        '''newFile(self, force)
Arguments:
	[in]	force = bool


Set everything back to a new file state.'''
        pass

    def beforeReferenceUserFileTranslator(self): 
        '''beforeReferenceUserFileTranslator(self) -> MPxFileTranslator
Returns: A pointer to the file translator being used for file reference, or NULL.


Retrieves the plug-in-defined file translator being used for file reference, if any. If a standard Maya file translator (e.g. mayaAscii) is being used, returns NULL. The translator can be retrieved from within the beforeRefenceCheck and beforeRefence callback functions. (that must be registered using  MSceneMessage::addCallback()  before the file is attempted to be referenced). If called outside of these two callback functions the results are undefined.'''
        pass

    def unloadReferenceByNode(self, referenceNode): 
        '''unloadReferenceByNode(self, referenceNode) -> MString
Returns: The name of the unloaded reference file

Arguments:
	[in]	referenceNode = MObject


Unloads the reference, referenced by the given reference node.'''
        pass

    def exportAll(self, fileName, type, preserveReferences): 
        '''exportAll(self, fileName, type, preserveReferences)
Arguments:
	[in]	fileName = MString
	[in]	type = char
	[in]	preserveReferences = bool


Export the current scene to the given file.'''
        pass

    def resetError(self): 
        '''resetError(self)

Resets the error.'''
        pass

class MFileObject:
    '''Manipulate Unix filenames and search paths. The MFileObject class implements an object that contains both a filename and a search path. The search path is specified by a single string in which multiple elements are separated by ':' characters. As well this string can contain Unix environment variables, specified as $VARNAME,Filenames can be produced by the class by combining the path element with the filename element of the MFileObject. As well, methods are available to test for the existance of the files produced. '''
    def __init__(self):
        pass


    def rawName(self): 
        '''rawName(self) -> MString


Returns the unresolved filename element of the  MFileObject .'''
        pass

    def ithFullName(self, index): 
        '''ithFullName(self, index) -> MString
Returns: An MString containing the pathname. 

Arguments:
	[in]	index = int


Returns the pathname of a file constructed from the indicated portion of the path element and filename element. All variables in the path element are expanded, and the indicated path portion is prepended to the filename element to construct the fullName.'''
        pass

    def pathCount(self): 
        '''pathCount(self) -> int


Returns the number of paths in the path element of the  MFileObject . This will be equal to one more than the number of ':' characters specified by the setRawPath method.'''
        pass

    def setRawPath(self, pathName): 
        '''setRawPath(self, pathName)
Arguments:
	[in]	pathName = MString


Set the unresolved path element of the  MFileObject  instance. This should contain a list of directories, each separated by a single ':' character. The pathnames can contain Unix environment variables in the form $VARNAME. These will be expanded when paths to actual filenames are constructed.'''
        pass

    def exists(self, index): 
        '''exists(self, index) -> bool

Arguments:
	[in]	index = int


Checks to see if the file constructed from the indicated portion of the path element and filename element exists and is readble.'''
        pass

    def rawPath(self): 
        '''rawPath(self) -> MString


Returns the path element of the  MFileObject  with all environment variables unexpanded.'''
        pass

    def isSet(self): 
        '''isSet(self) -> bool


Checks to see if both file and path elements of the  MFileObject  have been set.'''
        pass

    def setRawFullName(self, fullFileName): 
        '''setRawFullName(self, fullFileName)
Arguments:
	[in]	fullFileName = MString


This method combines the functions of the setRawName and setRawPath methods in that it sets both the path and filename from the given name.'''
        pass

    def setRawName(self, fileName): 
        '''setRawName(self, fileName)
Arguments:
	[in]	fileName = MString


Set the unresolved filename element of the  MFileObject  instance. This name should not contain any '/' characters, it should indicate simply the name of a file. The directories in which this name will be searched for are specified by setRawPath.'''
        pass

    def rawFullName(self): 
        '''rawFullName(self) -> MString


Returns the unrsolved full file name (path plus filename) of the  MFileObject  with all environment variables unexpanded.'''
        pass

    def expandedFullName(self): 
        '''expandedFullName(self) -> MString


Returns the first pathname of a file constructed from the path and filename elements. All variables in the path element are expanded, and the first path (the part before the first ':' in the path) is prepended to the filename element to construct the fullName.'''
        pass

    def overrideResolvedFullName(self, fullFileName): 
        '''overrideResolvedFullName(self, fullFileName)
Arguments:
	[in]	fullFileName = MString


Normally when a raw file name is set, Maya will perform a series of operations on it in an attempt to resolve it to a valid file name. This final resolved file name can be accessed through the  MFileObject::resolvedName() ,  MFileObject::resolvedPath() , and MFileObject::resolvedFullFileName() methods and can be quite different from the originally specified raw file name.'''
        pass

    def setResolveMethod(self, method): 
        '''setResolveMethod(self, method)
Arguments:
	[in]	method = MFileObject.MFileResolveMethod

'''
        pass

    def kReferenceMappings(self):
        '''This is an enum of MFileResolveMethod.
Description: Check path against any previously re-mapped reference locations. If kRelative/kBaseName are set, then even if we have an absolute path, convert to relative and/or baseName and look for them in directories provided to the missing reference dialog.
Value: 8'''
        pass

    def kRelative(self):
        '''This is an enum of MFileResolveMethod.
Description: Strips away the project directory, and treats path as relative. Relative to the current workspace, that is. So look in the workspace current directory, file-rules directory and the root directory
Value: 16'''
        pass

    def kInputReference(self):
        '''This is an enum of MFileResolveMethod.
Description: Default on file reference.
Value: 62'''
        pass

    def kBaseName(self):
        '''This is an enum of MFileResolveMethod.
Description: Strips away everything but the base file name and look in the current workspace.
Value: 32'''
        pass

    def kDirMap(self):
        '''This is an enum of MFileResolveMethod.
Description: Checks path against mappings defined with the dirmap command. Only for absolute paths.
Value: 4'''
        pass

    def kStrict(self):
        '''This is an enum of MFileResolveMethod.
Description: Equivalent to the file -strict flag.
Value: 6'''
        pass

    def kInputFile(self):
        '''This is an enum of MFileResolveMethod.
Description: Default on file open and import.
Value: 54'''
        pass

    def kExact(self):
        '''This is an enum of MFileResolveMethod.
Description: Checks if expanded paths exist. If paths are relative, assume it's relative to the current workspace (so check workspace current directory, file-rule directory and root directory
Value: 2'''
        pass

    def kNone(self):
        '''This is an enum of MFileResolveMethod.
Description: (Default) The resolved path is simply the first path after expanding any environment variables. Will not check if this file actually exists. User must explicitly check
Value: 1'''
        pass

    class MFileResolveMethod:
        '''Non-functional class.  Values for this enum:
        kReferenceMappings
        kRelative
        kInputReference
        kBaseName
        kDirMap
        kStrict
        kInputFile
        kExact
        kNone
'''
        def __init__(self):
            pass

    def resolvedPath(self): 
        '''resolvedPath(self) -> MString


Returns the resolved path element of the  MFileObject . In order to build the resolved path, Maya first expands all environment variables and then may perform additional modifications, such as prepending directories to a relative path name, in order to resolve the path to a valid location on disk.'''
        pass

    def expandedPath(self): 
        '''expandedPath(self) -> MString


Returns the path element of the  MFileObject  with all environment variables expanded.'''
        pass

    def ithPath(self, index): 
        '''ithPath(self, index) -> MString
Returns: An MString containing the path element. 

Arguments:
	[in]	index = int


Returns the indicated portion of the path element of the  MFileObject . All variables in the path element are expanded, and the portion indicated by the argument is extracted and returned.'''
        pass

    def resolvedFullName(self): 
        '''resolvedFullName(self) -> MString


Returns the first pathname of a file constructed from the path and filename elements. All variables in the path element are expanded, and the first path (the part before the first ':' in the path) is prepended to the filename element. After expanding all environment variables Maya may then perform additional modifications, such as prepending directories to a relative path name, in order to resolve the path to a valid location on disk.'''
        pass

    def resolveMethod(self): 
        '''resolveMethod(self) -> MFileObject.MFileResolveMethod


Returns the file-path resolution steps this object will use'''
        pass

    def resolvedName(self): 
        '''resolvedName(self) -> MString


Returns the resolved filename element of the  MFileObject .'''
        pass

class MFloatArray:
    '''Array of floats data type. This class implements an array of floats. Common convenience functions are available, and the implementation is compatible with the internal Maya implementation so that it can be passed efficiently between plugins and internal maya data structures.Methods that query the array are threadsafe. Writing to different array elements at the same time with the set() method is threadsafe. Methods that modify the array length, namely append(), insert(), remove() and setLength() are not threadsafe. '''
    def __init__(self):
        pass


    def insert(self, element, index): 
        '''insert(self, element, index)
Arguments:
	[in]	element = float
	[in]	index = int


Inserts a new value into the array at the given index. The initial element at that index, and all following elements, are shifted towards the last. If the array cannot be expanded in size by 1 element, then the insert will fail and the existing array will remain unchanged.'''
        pass

    def set(self, element, index): 
        '''set(self, element, index)
Arguments:
	[in]	element = double
	[in]	index = int


Sets the value of the indicated element to the indicated double value.'''
        pass

    def get(self, array): 
        '''get(self, array)
Arguments:
	[out]	array = double


Copy the elements of the array into the given C++ array of doubles. No checking is done to ensure that the destination C++ array of doubles is large enough to hold all the elements of the instance.'''
        pass

    def clear(self): 
        '''clear(self)
'''
        pass

    def sizeIncrement(self): 
        '''sizeIncrement(self) -> int


Return the size by which the array will be expanded whenever expansion is necessary.'''
        pass

    def remove(self, index): 
        '''remove(self, index)
Arguments:
	[in]	index = int


Remove the array element at the given index. All array elements following the removed element are shifted toward the first element.'''
        pass

    def length(self): 
        '''length(self) -> int


Returns the number of elements in the instance.'''
        pass

    def setSizeIncrement(self, newIncrement): 
        '''setSizeIncrement(self, newIncrement)
Arguments:
	[in]	newIncrement = int


Set the size by which the array will be expanded whenever expansion is necessary.'''
        pass

    def copy(self, source): 
        '''copy(self, source)
Arguments:
	[in]	source = MFloatArray


Copy the contents of the source array to this array.'''
        pass

    def setLength(self, length): 
        '''setLength(self, length)
Arguments:
	[in]	length = int


Set the length of the array. This will grow and shrink the array as desired. Elements that are grown have uninitialized values, while those which are shrunk will lose the data contained in the deleted elements (ie. it will release the memory).'''
        pass

    def append(self, element): 
        '''append(self, element)
Arguments:
	[in]	element = float


Adds a new element to the end of the array. If the array cannot be expanded in size by 1 element, then the append will fail and the existing array will remain unchanged.'''
        pass

class MFloatMatrix:
    '''A matrix math class for 4x4 matrices of floats. This class provides access to Maya's internal matrix math library allowing matrices to be handled easily, and in a manner compatible with internal Maya data structures. '''
    def __init__(self):
        pass


    def setToIdentity(self): 
        '''setToIdentity(self) -> MFloatMatrix


Set this instance to the 4x4 identity matrix.  Returns: A reference to this matrix.  
'''
        pass

    def inverse(self): 
        '''inverse(self) -> MFloatMatrix


Compute and return the inverse of this instance.'''
        pass

    def setToProduct(self, left, right): 
        '''setToProduct(self, left, right) -> MFloatMatrix
Returns: A reference to the result. 

Arguments:
	[in]	left = MFloatMatrix
	[in]	right = MFloatMatrix


Set this instance to the inner product of the two argument matrices.'''
        pass

    def homogenize(self): 
        '''homogenize(self) -> MFloatMatrix


Compute and return a homogenized version of this instance.'''
        pass

    def __getitem__(self, row): 
        '''__getitem__(self, row) -> float*
Returns: float array containing the values of the specified row 

Arguments:
	[in]	row = int


Index operator. Returns an entire row of the matrix as an array of floats.'''
        pass

    def get(self, dest): 
        '''get(self, dest)
Arguments:
	[out]	dest = float4


Fill a 4x4 matrix of floats with the elements from the instance.'''
        pass

    def __rmult__(self, factor): 
        '''__rmult__(self, factor) -> MFloatMatrix
Returns: A reference to the result. 

Arguments:
	[in]	factor = float


The in place matrix multiply by a scalar operator.  Parameters: 
 
 [in]   factor   scaling factor.  
 
 
 Returns: A reference to the result.  
'''
        pass

    def adjoint(self): 
        '''adjoint(self) -> MFloatMatrix


Compute and return the adjoint of this instance.'''
        pass

    def det4x4(self): 
        '''det4x4(self) -> float


Compute and return the determinant of this instance.'''
        pass

    def transpose(self): 
        '''transpose(self) -> MFloatMatrix


Compute and return the transpose of this instance.'''
        pass

    def isEquivalent(self, other, tolerance): 
        '''isEquivalent(self, other, tolerance) -> bool
Returns: True if the matrices are equivalent and false otherwise 

Arguments:
	[in]	other = MFloatMatrix
	[in]	tolerance = float


Determine if the given matrix is equivalent to this instance within the specified tolerance.'''
        pass

    def __radd__(self, right): 
        '''__radd__(self, right) -> MFloatMatrix
Returns: A reference to the result. 

Arguments:
	[in]	right = MFloatMatrix


The in place matrix addition operator.  Parameters: 
 
 [in]   right   Matrix to add.  
 
 
 Returns: A reference to the result.  
'''
        pass

    def det3x3(self): 
        '''det3x3(self) -> float


Compute and return the determinant of the upper left 3x3 submatrix of this instance.'''
        pass

    def __rsub__(self, right): 
        '''__rsub__(self, right) -> MFloatMatrix
Returns: A reference to the result. 

Arguments:
	[in]	right = MFloatMatrix


The in place matrix subtraction operator.  Parameters: 
 
 [in]   right   Matrix to subtract.  
 
 
 Returns: A reference to the result.  
'''
        pass

    def __mul__(self, factor): 
        '''__mul__(self, factor) -> MFloatMatrix
Returns: Scaled matrix. 

Arguments:
	[in]	factor = float


The matrix multiply by a scalar operator.  Parameters: 
 
 [in]   factor   Scaling factor.  
 
 
 Returns: Scaled matrix.  
'''
        pass

    def __add__(self, right): 
        '''__add__(self, right) -> MFloatMatrix
Returns: Sum of both matrices. 

Arguments:
	[in]	right = MFloatMatrix


The matrix addition operator.  Parameters: 
 
 [in]   right   Matrix to add.  
 
 
 Returns: Sum of both matrices.  
'''
        pass

    def __sub__(self, right): 
        '''__sub__(self, right) -> MFloatMatrix
Returns: Difference of both matrices. 

Arguments:
	[in]	right = MFloatMatrix


The matrix subtraction operator.  Parameters: 
 
 [in]   right   Matrix to subtract.  
 
 
 Returns: Difference of both matrices.  
'''
        pass

    def __eq__(self, other): 
        '''__eq__(self, other) -> bool
Returns: True is the matrices are identical. 

Arguments:
	[in]	other = MFloatMatrix


The matrix equality operator.  Parameters: 
 
 [in]   other   Matrix to test with.  
 
 
 Returns: True is the matrices are identical.  
'''
        pass

    def __neq__(self, other): 
        '''__neq__(self, other) -> bool
Returns: True is the matrices are not identical. 

Arguments:
	[in]	other = MFloatMatrix


The matrix inequality operator.  Parameters: 
 
 [in]   other   Matrix to test with.  
 
 
 Returns: True is the matrices are not identical.  
'''
        pass

class MFloatPoint:
    '''Implementation of a point. This class provides an implementation of a point in float. Numerous convienence operators are provided to help with the manipulation of points. This includes operators that work with the MFloatVector and MFloatMatrix classes.All methods that query the point are threadsafe, all methods that modify the point are not threadsafe. '''
    def __init__(self):
        pass


    def rationalize(self): 
        '''rationalize(self) -> MFloatPoint

'''
        pass

    def isEquivalent(self, other, tol): 
        '''isEquivalent(self, other, tol) -> bool
Returns: True if the points are equal within the given tolerance and false otherwise. 

Arguments:
	[in]	other = MFloatPoint
	[in]	tol = float


Returns true if this instance the the point passed as an argument represent the same position within the specified tolerance.'''
        pass

    def homogenize(self): 
        '''homogenize(self) -> MFloatPoint

'''
        pass

    def __getitem__(self, i): 
        '''__getitem__(self, i) -> float
Returns: The value of the indicated component of the instance. 

Arguments:
	[in]	i = int


The index operator.  
 If the argument is 0 it will return the x component of the constant instance.  
 If the argument is 1 it will return the y component of the constant instance.  
 If the argument is 2 it will return the z component of the constant instance.  
 If the argument is 3 it will return the w component of the constant instance. Otherwise it will return the x component of the point. 
 
 Parameters: 
 
 [in]   i   value indicating which component to return 
 
 
 Returns: The value of the indicated component of the instance.  
'''
        pass

    def get(self, dest): 
        '''get(self, dest)
Arguments:
	[out]	dest = float4


Copy the values of x, y, z, and w from the instance to the four elements of the given array of floats.'''
        pass

    def distanceTo(self, other): 
        '''distanceTo(self, other) -> float
Returns: The distance between the two points. 

Arguments:
	[in]	other = MFloatPoint


Return the distance between this instance and the point passed as an argument.'''
        pass

    def __rmult__(self, right): 
        '''__rmult__(self, right) -> MFloatPoint
Returns: A point representing the product 

Arguments:
	[in]	right = MFloatMatrix


The in-place multiplication operator for computing the product of this point instance with the given matrix.'''
        pass

    def cartesianize(self): 
        '''cartesianize(self) -> MFloatPoint

'''
        pass

    def __div__(self, scale): 
        '''__div__(self, scale) -> MFloatPoint
Returns: Scaled point. 

Arguments:
	[in]	scale = float


The division operator that allows the vector to by scaled by the given float parameter. The x, y, and z components are each divided by the parameter. The w component remains unchanged.'''
        pass

    def __radd__(self, vector): 
        '''__radd__(self, vector) -> MFloatPoint

Arguments:
	[in]	vector = MFloatVector


The in-place addition operator for adding an  MFloatVector  to an  MFloatPoint . The current instance is translated from its original position by the vector.'''
        pass

    def setCast(self, d): 
        '''setCast(self, d)
Arguments:
	[in]	d = double4


Copy the values of x, y, z, and w to the instance from the four elements of the given array of doubles. Note that this operation will lose precision as it casts from double to single-precision floating point.'''
        pass

    def __rsub__(self, vector): 
        '''__rsub__(self, vector) -> MFloatPoint

Arguments:
	[in]	vector = MFloatVector


The in-place subtraction operator for subtracting an  MFloatVector  from an  MFloatPoint . The current instance is translated from its original position by the inverse of the vector.'''
        pass

    def __mul__(self, right): 
        '''__mul__(self, right) -> MFloatPoint
Returns: A point representing the product 

Arguments:
	[in]	right = MFloatMatrix


The multiplication operator for computing the product of this point instance with the given matrix.'''
        pass

    def __add__(self, other): 
        '''__add__(self, other) -> MFloatPoint

Arguments:
	[in]	other = MFloatVector


The operator for adding an  MFloatVector  to an  MFloatPoint . A new point is returned whose position is that of the original point translated by the vector.'''
        pass

    def __sub__(self, other): 
        '''__sub__(self, other) -> MFloatPoint

Arguments:
	[in]	other = MFloatVector


The operator for subtracting an  MFloatVector  from an  MFloatPoint . A new point is returned whose position is that of the original point translated by the inverse of the vector.'''
        pass

    def __eq__(self, other): 
        '''__eq__(self, other) -> bool

Arguments:
	[in]	other = MFloatPoint


The equality operator. Returns true if all of the x, y, z, and w components of the two points are identical.'''
        pass

    def __neq__(self, other): 
        '''__neq__(self, other) -> bool

Arguments:
	[in]	other = MFloatPoint


The inequality operator. Returns true if any of the x, y, z, and w components of the two points are not identical.'''
        pass

class MFloatPointArray:
    '''Array of MFloatPoint data type. This class implements an array of MFloatPoints. Common convenience functions are available, and the implementation is compatible with the internal Maya implementation so that it can be passed efficiently between plugins and internal maya data structures. '''
    def __init__(self):
        pass


    def insert(self, element, index): 
        '''insert(self, element, index)
Arguments:
	[in]	element = MFloatPoint
	[in]	index = int


Inserts a new value into the array at the given index. The initial element at that index, and all following elements, are shifted towards the last. If the array cannot be expanded in size by 1 element, then the insert will fail and the existing array will remain unchanged.'''
        pass

    def set(self, val, index): 
        '''set(self, val, index)
Arguments:
	[in]	val = double4
	[in]	index = int


Sets the value of the indicated element to the indicated value. The x component of the element is set to val[0], the y component to val[1], the z component to val[2], and the w component to val[3].'''
        pass

    def get(self, dest): 
        '''get(self, dest)
Arguments:
	[out]	dest = double


Copy the elements of the array into the C++ array of double arrays. No checking is done to ensure that the destination C++ array of double arrays is large enough to hold all the elements of the instance.'''
        pass

    def clear(self): 
        '''clear(self)

Clear the contents of the array. After this operation the length method will return 0. This does not change the amount of memory allocated to the array, only the number of valid elements in it.'''
        pass

    def sizeIncrement(self): 
        '''sizeIncrement(self) -> int


Return the size by which the array will be expanded whenever expansion is necessary.'''
        pass

    def MFloatPoint(self, index): 
        '''MFloatPoint(self, index) -> const
Returns: The value of the indicated element. 

Arguments:
	[in]	index = int


Index operator. Returns the value of the element at the given index. No range checking is done - valid indices are 0 to  length() -1.'''
        pass

    def remove(self, index): 
        '''remove(self, index)
Arguments:
	[in]	index = int


Remove the array element at the given index. All array elements following the removed element are shifted toward the first element.'''
        pass

    def length(self): 
        '''length(self) -> int


Returns the number of elements in the instance.'''
        pass

    def setSizeIncrement(self, newIncrement): 
        '''setSizeIncrement(self, newIncrement)
Arguments:
	[in]	newIncrement = int


Set the size by which the array will be expanded whenever expansion is necessary.'''
        pass

    def copy(self, source): 
        '''copy(self, source)
Arguments:
	[in]	source = MFloatPointArray


Copy the contents of the source array to this array.'''
        pass

    def setLength(self, length): 
        '''setLength(self, length)
Arguments:
	[in]	length = int


Set the length of the array. This will grow and shrink the array as desired. Elements that are grown have uninitialized values, while those which are shrunk will lose the data contained in the deleted elements (ie. it will release the memory).'''
        pass

    def append(self, x, y, z, w): 
        '''append(self, x, y, z, w)
Arguments:
	[in]	x = float
	[in]	y = float
	[in]	z = float
	[in]	w = float


Adds a new element to the end of the array. The appended element has the indicated values for its x,y,z and w components. The x component of the element is set to x, the y component to y, the z component to z, and the w component to w.'''
        pass

class MFloatVector:
    '''A vector math class for vectors of floats. This class provides access to Maya's internal vector math library allowing vectors to be handled easily, and in a manner compatible with internal Maya data structures.All methods that query the vector are threadsafe, all methods that modify the vector are not threadsafe. '''
    def __init__(self):
        pass


    yAxis = ''
    '''Unit vector in the positive y direction. '''

    yNegAxis = ''
    '''Unit vector in the negative z direction. '''

    zNegAxis = ''
    '''Unit vector in the negative z direction. '''

    one = ''
    '''The vector <1.0,1.0,1.0>. '''

    xNegAxis = ''
    '''Unit vector in the negative z direction. '''

    zero = ''
    '''The null vector. '''

    zAxis = ''
    '''Unit vector in the positive z direction. '''

    xAxis = ''
    '''Unit vector in the positive x direction. '''

    def normalize(self): 
        '''normalize(self)

Performs an in place normalization of the vector'''
        pass

    def angle(self, other): 
        '''angle(self, other) -> float
Returns: The angle in radians 

Arguments:
	[in]	other = MFloatVector


Returns the angle in radians between the vector and the one passed as an argument.'''
        pass

    def isEquivalent(self, other, tol): 
        '''isEquivalent(self, other, tol) -> bool
Returns: true if the vectors are equivalent and false otherwise 

Arguments:
	[in]	other = MFloatVector
	[in]	tol = float


Returns true if the vector and the one passed as an argument are equal to each other within the specified tolerance.'''
        pass

    def __getitem__(self, i): 
        '''__getitem__(self, i) -> float
Returns: The vector component. 

Arguments:
	[in]	i = int


The index operator. If its argument is 0 it will return the x component of the vector. If its argument is 1 it will return the y component of the vector. Otherwise it will return the z component of the vector.'''
        pass

    def get(self, d): 
        '''get(self, d)
Arguments:
	[out]	d = float3


Extracts the x, y, and z components of the vector and places them in elements 0, 1, and 2 of the float array passed.'''
        pass

    def __rmult__(self, right): 
        '''__rmult__(self, right) -> MFloatVector

Arguments:
	[in]	right = MFloatMatrix

'''
        pass

    def normal(self): 
        '''normal(self) -> MFloatVector


Computes a unit vector aligned to the vector.  Returns: The unit vector.  
  Reprocessed example  
 Examples: 
 
   
 sampleParticles.cpp . 
 
'''
        pass

    def length(self): 
        '''length(self) -> float


 Returns: The length of the vector.  
'''
        pass

    def __radd__(self, other): 
        '''__radd__(self, other) -> MFloatVector
Returns: A reference to the resulting vector. 

Arguments:
	[in]	other = MFloatVector


The in place vector addition operator.'''
        pass

    def isParallel(self, other, tol): 
        '''isParallel(self, other, tol) -> bool
Returns: true if the vectors are parallel and false otherwise 

Arguments:
	[in]	other = MFloatVector
	[in]	tol = float


Returns true if the current vector and the one passed as an argument are parallel to each other within the specified tolerance.'''
        pass

    def __div__(self, scalar): 
        '''__div__(self, scalar) -> MFloatVector
Returns: The scaled vector. 

Arguments:
	[in]	scalar = float


The division operator.'''
        pass

    def __rsub__(self, other): 
        '''__rsub__(self, other) -> MFloatVector
Returns: A reference to the resulting vector. 

Arguments:
	[in]	other = MFloatVector


The in place vector subtraction operator.'''
        pass

    def __mul__(self, right): 
        '''__mul__(self, right) -> float
Returns: Dot product value. 

Arguments:
	[in]	right = MFloatVector


The dot product operator.'''
        pass

    def __add__(self, other): 
        '''__add__(self, other) -> MFloatVector
Returns: The resulting vector. 

Arguments:
	[in]	other = MFloatVector


The vector addition operator.'''
        pass

    def __rdiv__(self, scalar): 
        '''__rdiv__(self, scalar) -> MFloatVector
Returns: A reference to the scaled vector. 

Arguments:
	[in]	scalar = float


The in place division operator.'''
        pass

    def __sub__(self, other): 
        '''__sub__(self, other) -> MFloatVector
Returns: The resulting vector. 

Arguments:
	[in]	other = MFloatVector


The vector subtraction operator.'''
        pass

    def __eq__(self, other): 
        '''__eq__(self, other) -> bool
Returns: Bool true if the vectors are identical and false otherwise. 

Arguments:
	[in]	other = MFloatVector


The vector equality operator. This returns true if all three of the x, y, and z components are identical.'''
        pass

    def __neq__(self, other): 
        '''__neq__(self, other) -> bool
Returns: Bool false if the vectors are identical and true otherwise. 

Arguments:
	[in]	other = MFloatVector


The vector inequality operator. This returns false if all three of the x, y, and z components are identical.'''
        pass

class MFloatVectorArray:
    '''Array of MFloatVectors data type. This class implements an array of MFloatVectors. Common convenience functions are available, and the implementation is compatible with the internal Maya implementation so that it can be passed efficiently between plugins and internal maya data structures. '''
    def __init__(self):
        pass


    def insert(self, element, index): 
        '''insert(self, element, index)
Arguments:
	[in]	element = MFloatVector
	[in]	index = int


Inserts a new value into the array at the given index. The initial element at that index, and all following elements, are shifted towards the last. If the array cannot be expanded in size by 1 element, then the insert will fail and the existing array will remain unchanged.'''
        pass

    def set(self, element, index): 
        '''set(self, element, index)
Arguments:
	[in]	element = float3
	[in]	index = int


Sets the value of the indicated element to the indicated float array value.'''
        pass

    def get(self, array): 
        '''get(self, array)
Arguments:
	[out]	array = float


Copy the elements of the array into the given C++ array of float arrays. No checking is done to ensure that the destination C++ array of floats arrays is large enough to hold all the elements of the instance.'''
        pass

    def clear(self): 
        '''clear(self)

Clear the contents of the array. After this operation the length method will return 0. This does not change the amount of memory allocated to the array, only the number of valid elements in it.'''
        pass

    def sizeIncrement(self): 
        '''sizeIncrement(self) -> int


Return the size by which the array will be expanded whenever expansion is necessary.'''
        pass

    def remove(self, index): 
        '''remove(self, index)
Arguments:
	[in]	index = int


Remove the array element at the given index. All array elements following the removed element are shifted toward the first element.'''
        pass

    def length(self): 
        '''length(self) -> int


Returns the number of elements in the instance.'''
        pass

    def setSizeIncrement(self, newIncrement): 
        '''setSizeIncrement(self, newIncrement)
Arguments:
	[in]	newIncrement = int


Set the size by which the array will be expanded whenever expansion is necessary.'''
        pass

    def copy(self, source): 
        '''copy(self, source)
Arguments:
	[in]	source = MFloatVectorArray


Copy the contents of the source array to this array.'''
        pass

    def MFloatVector(self, index): 
        '''MFloatVector(self, index) -> const
Returns: The value of the indicated element. 

Arguments:
	[in]	index = int


Index operator. Returns the value of the element at the given index. No range checking is done - valid indices are 0 to  length() -1.'''
        pass

    def setLength(self, length): 
        '''setLength(self, length)
Arguments:
	[in]	length = int


Set the length of the array. This will grow and shrink the array as desired. Elements that are grown have uninitialized values, while those which are shrunk will lose the data contained in the deleted elements (ie. it will release the memory).'''
        pass

    def append(self, element): 
        '''append(self, element)
Arguments:
	[in]	element = MFloatVector


Adds a new element to the end of the array. If the array cannot be expanded in size by 1 element, then the append will fail and the existing array will remain unchanged.'''
        pass

class MFn:
    '''Function Set Type Identifiers. MFn encapsulates all API Function Set type identifiers used for RTTI in the API. '''
    def __init__(self):
        pass


    def kPolyCollapseF(self):
        '''This is an enum of Type.
Description: 
Value: 396'''
        pass

    def kNCloth(self):
        '''This is an enum of Type.
Description: 
Value: 981'''
        pass

    def kPolyPoke(self):
        '''This is an enum of Type.
Description: 
Value: 882'''
        pass

    def kPluginHwShaderNode(self):
        '''This is an enum of Type.
Description: Custom hardware shader derived from
Value: 871'''
        pass

    def kPolyCube(self):
        '''This is an enum of Type.
Description: 
Value: 427'''
        pass

    def kMarkerManip(self):
        '''This is an enum of Type.
Description: 
Value: 210'''
        pass

    def kTranslateManip(self):
        '''This is an enum of Type.
Description: 
Value: 227'''
        pass

    def kSubSurface(self):
        '''This is an enum of Type.
Description: 
Value: 765'''
        pass

    def kPolyBridgeEdge(self):
        '''This is an enum of Type.
Description: 
Value: 969'''
        pass

    def kCacheFile(self):
        '''This is an enum of Type.
Description: 
Value: 963'''
        pass

    def kIsoparmManip(self):
        '''This is an enum of Type.
Description: 
Value: 146'''
        pass

    def kBallProjectionManip(self):
        '''This is an enum of Type.
Description: 
Value: 125'''
        pass

    def kOffsetSurface(self):
        '''This is an enum of Type.
Description: 
Value: 630'''
        pass

    def kPolyMapSew(self):
        '''This is an enum of Type.
Description: 
Value: 404'''
        pass

    def kMarker(self):
        '''This is an enum of Type.
Description: 
Value: 282'''
        pass

    def kGrid(self):
        '''This is an enum of Type.
Description: 
Value: 490'''
        pass

    def kDiffuseMaterial(self):
        '''This is an enum of Type.
Description: 
Value: 377'''
        pass

    def kTweak(self):
        '''This is an enum of Type.
Description: 
Value: 341'''
        pass

    def kManipulator2D(self):
        '''This is an enum of Type.
Description: 
Value: 205'''
        pass

    def kKeyframeDeltaBlockAddRemove(self):
        '''This is an enum of Type.
Description: 
Value: 932'''
        pass

    def kSelectionListData(self):
        '''This is an enum of Type.
Description: 
Value: 660'''
        pass

    def kLightSource(self):
        '''This is an enum of Type.
Description: 
Value: 373'''
        pass

    def kDimension(self):
        '''This is an enum of Type.
Description: 
Value: 268'''
        pass

    def kDetachSurface(self):
        '''This is an enum of Type.
Description: 
Value: 64'''
        pass

    def kPolyLayoutUV(self):
        '''This is an enum of Type.
Description: 
Value: 832'''
        pass

    def kPolyCreateFacet(self):
        '''This is an enum of Type.
Description: 
Value: 432'''
        pass

    def kCurveFromSurfaceBnd(self):
        '''This is an enum of Type.
Description: 
Value: 59'''
        pass

    def kCircle(self):
        '''This is an enum of Type.
Description: 
Value: 54'''
        pass

    def kExtrude(self):
        '''This is an enum of Type.
Description: 
Value: 67'''
        pass

    def kParticleCloud(self):
        '''This is an enum of Type.
Description: 
Value: 440'''
        pass

    def kMeshPolygonComponent(self):
        '''This is an enum of Type.
Description: 
Value: 540'''
        pass

    def kLayeredShader(self):
        '''This is an enum of Type.
Description: 
Value: 367'''
        pass

    def kLatticeData(self):
        '''This is an enum of Type.
Description: 
Value: 574'''
        pass

    def kDisplacementShader(self):
        '''This is an enum of Type.
Description: 
Value: 320'''
        pass

    def kPolyBoolOp(self):
        '''This is an enum of Type.
Description: 
Value: 603'''
        pass

    def kPointOnLineManip(self):
        '''This is an enum of Type.
Description: 
Value: 211'''
        pass

    def kPointArrayData(self):
        '''This is an enum of Type.
Description: 
Value: 589'''
        pass

    def kTransform(self):
        '''This is an enum of Type.
Description: 
Value: 110'''
        pass

    def kRebuildCurve(self):
        '''This is an enum of Type.
Description: 
Value: 90'''
        pass

    def kData(self):
        '''This is an enum of Type.
Description: 
Value: 570'''
        pass

    def kBump3d(self):
        '''This is an enum of Type.
Description: 
Value: 33'''
        pass

    def kDoubleLinearAttribute(self):
        '''This is an enum of Type.
Description: 
Value: 557'''
        pass

    def kProjection(self):
        '''This is an enum of Type.
Description: 
Value: 453'''
        pass

    def kScreenAlignedCircleManip(self):
        '''This is an enum of Type.
Description: 
Value: 127'''
        pass

    def kData2Long(self):
        '''This is an enum of Type.
Description: Used for backward compatibility.
Value: 582'''
        pass

    def kEnvChrome(self):
        '''This is an enum of Type.
Description: 
Value: 481'''
        pass

    def kResultCurve(self):
        '''This is an enum of Type.
Description: 
Value: 16'''
        pass

    def kDPbirailSrf(self):
        '''This is an enum of Type.
Description: 
Value: 50'''
        pass

    def kImageData(self):
        '''This is an enum of Type.
Description: 
Value: 639'''
        pass

    def kCurveNormalizerLinear(self):
        '''This is an enum of Type.
Description: 
Value: 978'''
        pass

    def kEnvFogShape(self):
        '''This is an enum of Type.
Description: 
Value: 277'''
        pass

    def kSetRange(self):
        '''This is an enum of Type.
Description: 
Value: 462'''
        pass

    def kImplicitCone(self):
        '''This is an enum of Type.
Description: 
Value: 874'''
        pass

    def kMembrane(self):
        '''This is an enum of Type.
Description: 
Value: 1009'''
        pass

    def kVolumeNoise(self):
        '''This is an enum of Type.
Description: 
Value: 856'''
        pass

    def kTrim(self):
        '''This is an enum of Type.
Description: 
Value: 105'''
        pass

    def kCopyUVSet(self):
        '''This is an enum of Type.
Description: 
Value: 788'''
        pass

    def kLineArrowManip(self):
        '''This is an enum of Type.
Description: 
Value: 235'''
        pass

    def kScaleUVManip2D(self):
        '''This is an enum of Type.
Description: 
Value: 692'''
        pass

    def kCompoundAttribute(self):
        '''This is an enum of Type.
Description: 
Value: 563'''
        pass

    def kSquareSrfManip(self):
        '''This is an enum of Type.
Description: 
Value: 702'''
        pass

    def kRock(self):
        '''This is an enum of Type.
Description: 
Value: 502'''
        pass

    def kBlendDevice(self):
        '''This is an enum of Type.
Description: 
Value: 30'''
        pass

    def kPolySeparate(self):
        '''This is an enum of Type.
Description: 
Value: 451'''
        pass

    def kSkin(self):
        '''This is an enum of Type.
Description: 
Value: 100'''
        pass

    def kData3Int(self):
        '''This is an enum of Type.
Description: 
Value: 586'''
        pass

    def kStereoCameraMaster(self):
        '''This is an enum of Type.
Description: Master node for a stereo camera rig.
Value: 1019'''
        pass

    def kNurbsTesselate(self):
        '''This is an enum of Type.
Description: 
Value: 78'''
        pass

    def kSurfaceKnotComponent(self):
        '''This is an enum of Type.
Description: 
Value: 532'''
        pass

    def kLattice(self):
        '''This is an enum of Type.
Description: 
Value: 278'''
        pass

    def kMaterial(self):
        '''This is an enum of Type.
Description: 
Value: 376'''
        pass

    def kOffsetCurveManip(self):
        '''This is an enum of Type.
Description: 
Value: 172'''
        pass

    def kWater(self):
        '''This is an enum of Type.
Description: 
Value: 494'''
        pass

    def kAlignManip(self):
        '''This is an enum of Type.
Description: 
Value: 891'''
        pass

    def kDynParticleSetComponent(self):
        '''This is an enum of Type.
Description: 
Value: 548'''
        pass

    def kStudioClearCoat(self):
        '''This is an enum of Type.
Description: 
Value: 898'''
        pass

    def kAnyGeometryVarGroup(self):
        '''This is an enum of Type.
Description: 
Value: 115'''
        pass

    def kFfdDualBase(self):
        '''This is an enum of Type.
Description: 
Value: 338'''
        pass

    def kBevel(self):
        '''This is an enum of Type.
Description: 
Value: 48'''
        pass

    def kNurbsCircular2PtArc(self):
        '''This is an enum of Type.
Description: 
Value: 629'''
        pass

    def kPolyFlipEdge(self):
        '''This is an enum of Type.
Description: 
Value: 773'''
        pass

    def kHikEffector(self):
        '''This is an enum of Type.
Description: 
Value: 939'''
        pass

    def kMPbirailSrf(self):
        '''This is an enum of Type.
Description: 
Value: 51'''
        pass

    def kTripleShadingSwitch(self):
        '''This is an enum of Type.
Description: 
Value: 606'''
        pass

    def kSubdSubdivideFace(self):
        '''This is an enum of Type.
Description: 
Value: 858'''
        pass

    def kPolyMoveFacet(self):
        '''This is an enum of Type.
Description: 
Value: 408'''
        pass

    def kData2Double(self):
        '''This is an enum of Type.
Description: 
Value: 580'''
        pass

    def kEnvFacade(self):
        '''This is an enum of Type.
Description: 
Value: 952'''
        pass

    def kAttribute3Double(self):
        '''This is an enum of Type.
Description: 
Value: 735'''
        pass

    def kSubdivCompId(self):
        '''This is an enum of Type.
Description: 
Value: 779'''
        pass

    def kBoundary(self):
        '''This is an enum of Type.
Description: 
Value: 53'''
        pass

    def kDiscManip(self):
        '''This is an enum of Type.
Description: 
Value: 132'''
        pass

    def kRoundConstantRadiusManip(self):
        '''This is an enum of Type.
Description: 
Value: 634'''
        pass

    def kUnknownTransform(self):
        '''This is an enum of Type.
Description: 
Value: 245'''
        pass

    def kDeformSineManip(self):
        '''This is an enum of Type.
Description: 
Value: 621'''
        pass

    def kPolyCylinder(self):
        '''This is an enum of Type.
Description: 
Value: 428'''
        pass

    def kImageAdd(self):
        '''This is an enum of Type.
Description: 
Value: 645'''
        pass

    def kViewManip(self):
        '''This is an enum of Type.
Description: 
Value: 908'''
        pass

    def kDynBase(self):
        '''This is an enum of Type.
Description: 
Value: 704'''
        pass

    def kImageSave(self):
        '''This is an enum of Type.
Description: 
Value: 641'''
        pass

    def kKeyframeDeltaTangent(self):
        '''This is an enum of Type.
Description: 
Value: 934'''
        pass

    def kDimensionManip(self):
        '''This is an enum of Type.
Description: 
Value: 232'''
        pass

    def kRadius(self):
        '''This is an enum of Type.
Description: 
Value: 273'''
        pass

    def kPivotManip2D(self):
        '''This is an enum of Type.
Description: 
Value: 191'''
        pass

    def kPluginManipulatorNode(self):
        '''This is an enum of Type.
Description: Custom manipulator node derived from
Value: 1006'''
        pass

    def kCrossSectionEditManip(self):
        '''This is an enum of Type.
Description: 
Value: 805'''
        pass

    def kImageLoad(self):
        '''This is an enum of Type.
Description: 
Value: 640'''
        pass

    def kRevolvedPrimitiveManip(self):
        '''This is an enum of Type.
Description: 
Value: 185'''
        pass

    def kCpManip(self):
        '''This is an enum of Type.
Description: 
Value: 156'''
        pass

    def kLightDataAttribute(self):
        '''This is an enum of Type.
Description: 
Value: 565'''
        pass

    def kBlendNodeDoubleAngle(self):
        '''This is an enum of Type.
Description: 
Value: 996'''
        pass

    def kLookAt(self):
        '''This is an enum of Type.
Description: 
Value: 112'''
        pass

    def kSurfaceEPComponent(self):
        '''This is an enum of Type.
Description: 
Value: 531'''
        pass

    def kAnimBlend(self):
        '''This is an enum of Type.
Description: 
Value: 775'''
        pass

    def kSphericalProjectionManip(self):
        '''This is an enum of Type.
Description: 
Value: 222'''
        pass

    def kMidModifier(self):
        '''This is an enum of Type.
Description: 
Value: 388'''
        pass

    def kFluidTexture3D(self):
        '''This is an enum of Type.
Description: 
Value: 887'''
        pass

    def kPairBlend(self):
        '''This is an enum of Type.
Description: 
Value: 906'''
        pass

    def kDynAttenuationManip(self):
        '''This is an enum of Type.
Description: 
Value: 712'''
        pass

    def kMesh(self):
        '''This is an enum of Type.
Description: 
Value: 295'''
        pass

    def kSpring(self):
        '''This is an enum of Type.
Description: 
Value: 314'''
        pass

    def kPolyCloseBorder(self):
        '''This is an enum of Type.
Description: 
Value: 394'''
        pass

    def kPolySoftEdge(self):
        '''This is an enum of Type.
Description: 
Value: 418'''
        pass

    def kLodGroup(self):
        '''This is an enum of Type.
Description: 
Value: 757'''
        pass

    def kManip2DContainer(self):
        '''This is an enum of Type.
Description: 
Value: 192'''
        pass

    def kSelectionList(self):
        '''This is an enum of Type.
Description: 
Value: 594'''
        pass

    def kBaseLattice(self):
        '''This is an enum of Type.
Description: 
Value: 248'''
        pass

    def kAnimCurveUnitlessToTime(self):
        '''This is an enum of Type.
Description: 
Value: 14'''
        pass

    def kCameraPlaneManip(self):
        '''This is an enum of Type.
Description: 
Value: 143'''
        pass

    def kPolyCut(self):
        '''This is an enum of Type.
Description: 
Value: 881'''
        pass

    def kScalingBoxManip(self):
        '''This is an enum of Type.
Description: 
Value: 220'''
        pass

    def kGeoConnector(self):
        '''This is an enum of Type.
Description: 
Value: 901'''
        pass

    def kObjectMultiFilter(self):
        '''This is an enum of Type.
Description: 
Value: 662'''
        pass

    def kFloatVectorArrayData(self):
        '''This is an enum of Type.
Description: 
Value: 986'''
        pass

    def kRbfSrfManip(self):
        '''This is an enum of Type.
Description: 
Value: 180'''
        pass

    def kSubdLayoutUV(self):
        '''This is an enum of Type.
Description: 
Value: 853'''
        pass

    def kMeshFrEdgeComponent(self):
        '''This is an enum of Type.
Description: 
Value: 541'''
        pass

    def kSetGroupComponent(self):
        '''This is an enum of Type.
Description: 
Value: 547'''
        pass

    def kHardenPointCurve(self):
        '''This is an enum of Type.
Description: 
Value: 73'''
        pass

    def kSnapshotPath(self):
        '''This is an enum of Type.
Description: 
Value: 902'''
        pass

    def kArrayMapper(self):
        '''This is an enum of Type.
Description: 
Value: 516'''
        pass

    def kOpticalFX(self):
        '''This is an enum of Type.
Description: 
Value: 438'''
        pass

    def kReverse(self):
        '''This is an enum of Type.
Description: 
Value: 456'''
        pass

    def kCreateUVSet(self):
        '''This is an enum of Type.
Description: 
Value: 789'''
        pass

    def kAttribute3Int(self):
        '''This is an enum of Type.
Description: 
Value: 738'''
        pass

    def kFollicle(self):
        '''This is an enum of Type.
Description: 
Value: 914'''
        pass

    def kPolyComponentData(self):
        '''This is an enum of Type.
Description: 
Value: 961'''
        pass

    def kOcean(self):
        '''This is an enum of Type.
Description: 
Value: 855'''
        pass

    def kUvChooser(self):
        '''This is an enum of Type.
Description: 
Value: 778'''
        pass

    def kTimeToUnitConversion(self):
        '''This is an enum of Type.
Description: 
Value: 509'''
        pass

    def kOrientationComponent(self):
        '''This is an enum of Type.
Description: 
Value: 544'''
        pass

    def kFlow(self):
        '''This is an enum of Type.
Description: 
Value: 72'''
        pass

    def kCirclePointManip(self):
        '''This is an enum of Type.
Description: 
Value: 231'''
        pass

    def kBlendShape(self):
        '''This is an enum of Type.
Description: 
Value: 335'''
        pass

    def kWriteToColorBuffer(self):
        '''This is an enum of Type.
Description: 
Value: 1015'''
        pass

    def kNRigid(self):
        '''This is an enum of Type.
Description: 
Value: 983'''
        pass

    def kAnimCurveTimeToUnitless(self):
        '''This is an enum of Type.
Description: 
Value: 11'''
        pass

    def kSubdMoveFace(self):
        '''This is an enum of Type.
Description: 
Value: 837'''
        pass

    def kDagPose(self):
        '''This is an enum of Type.
Description: 
Value: 674'''
        pass

    def kDynAirManip(self):
        '''This is an enum of Type.
Description: 
Value: 708'''
        pass

    def kPolyDelFacet(self):
        '''This is an enum of Type.
Description: 
Value: 399'''
        pass

    def kPolyArrow(self):
        '''This is an enum of Type.
Description: 
Value: 955'''
        pass

    def kNObject(self):
        '''This is an enum of Type.
Description: 
Value: 988'''
        pass

    def kAnnotation(self):
        '''This is an enum of Type.
Description: 
Value: 270'''
        pass

    def kConcentricProjectionManip(self):
        '''This is an enum of Type.
Description: 
Value: 129'''
        pass

    def kLast(self):
        '''This is an enum of Type.
Description: Defines the last entry.
Value: 1020'''
        pass

    def kPolyTweak(self):
        '''This is an enum of Type.
Description: 
Value: 391'''
        pass

    def kAnimCurveUnitlessToAngular(self):
        '''This is an enum of Type.
Description: 
Value: 12'''
        pass

    def kPropModManip(self):
        '''This is an enum of Type.
Description: 
Value: 178'''
        pass

    def kProjectionManip(self):
        '''This is an enum of Type.
Description: 
Value: 173'''
        pass

    def kAlignSurface(self):
        '''This is an enum of Type.
Description: 
Value: 42'''
        pass

    def kCone(self):
        '''This is an enum of Type.
Description: 
Value: 96'''
        pass

    def kSymmetryMapCurve(self):
        '''This is an enum of Type.
Description: 
Value: 815'''
        pass

    def kTextureList(self):
        '''This is an enum of Type.
Description: 
Value: 477'''
        pass

    def kJointClusterManip(self):
        '''This is an enum of Type.
Description: 
Value: 168'''
        pass

    def kPolySplitToolManip(self):
        '''This is an enum of Type.
Description: 
Value: 141'''
        pass

    def kRampBackground(self):
        '''This is an enum of Type.
Description: 
Value: 26'''
        pass

    def kSurfaceCVComponent(self):
        '''This is an enum of Type.
Description: 
Value: 530'''
        pass

    def kDropOffFunction(self):
        '''This is an enum of Type.
Description: 
Value: 806'''
        pass

    def kTime(self):
        '''This is an enum of Type.
Description: 
Value: 508'''
        pass

    def kBlendNodeFloatAngle(self):
        '''This is an enum of Type.
Description: 
Value: 1000'''
        pass

    def kShadingEngine(self):
        '''This is an enum of Type.
Description: 
Value: 319'''
        pass

    def kSmear(self):
        '''This is an enum of Type.
Description: 
Value: 896'''
        pass

    def kPointMatrixMult(self):
        '''This is an enum of Type.
Description: 
Value: 450'''
        pass

    def kAttachSurface(self):
        '''This is an enum of Type.
Description: 
Value: 44'''
        pass

    def kSamplerInfo(self):
        '''This is an enum of Type.
Description: 
Value: 466'''
        pass

    def kData3Short(self):
        '''This is an enum of Type.
Description: 
Value: 587'''
        pass

    def kTransformBoxManip(self):
        '''This is an enum of Type.
Description: 
Value: 812'''
        pass

    def kField(self):
        '''This is an enum of Type.
Description: 
Value: 255'''
        pass

    def kCommEdgeOperManip(self):
        '''This is an enum of Type.
Description: 
Value: 597'''
        pass

    def kQuadPtOnLineManip(self):
        '''This is an enum of Type.
Description: 
Value: 179'''
        pass

    def kPolyNormalizeUV(self):
        '''This is an enum of Type.
Description: 
Value: 867'''
        pass

    def kSubdivFaceComponent(self):
        '''This is an enum of Type.
Description: 
Value: 688'''
        pass

    def kAffect(self):
        '''This is an enum of Type.
Description: 
Value: 6'''
        pass

    def kImageFilter(self):
        '''This is an enum of Type.
Description: 
Value: 652'''
        pass

    def kSurfaceShader(self):
        '''This is an enum of Type.
Description: 
Value: 476'''
        pass

    def kSubdModifier(self):
        '''This is an enum of Type.
Description: 
Value: 834'''
        pass

    def kDeformFunc(self):
        '''This is an enum of Type.
Description: 
Value: 610'''
        pass

    def kImageNetDest(self):
        '''This is an enum of Type.
Description: 
Value: 643'''
        pass

    def kRotateBoxManip(self):
        '''This is an enum of Type.
Description: 
Value: 214'''
        pass

    def kObjectAttrFilter(self):
        '''This is an enum of Type.
Description: 
Value: 665'''
        pass

    def kSoftMod(self):
        '''This is an enum of Type.
Description: 
Value: 251'''
        pass

    def kDirectionManip(self):
        '''This is an enum of Type.
Description: 
Value: 161'''
        pass

    def kTexture3d(self):
        '''This is an enum of Type.
Description: 
Value: 495'''
        pass

    def kDeformBendManip(self):
        '''This is an enum of Type.
Description: 
Value: 617'''
        pass

    def kEnumAttribute(self):
        '''This is an enum of Type.
Description: 
Value: 560'''
        pass

    def kUniform(self):
        '''This is an enum of Type.
Description: 
Value: 262'''
        pass

    def kPointOnCurveManip(self):
        '''This is an enum of Type.
Description: 
Value: 208'''
        pass

    def kPartition(self):
        '''This is an enum of Type.
Description: 
Value: 444'''
        pass

    def kAudio(self):
        '''This is an enum of Type.
Description: 
Value: 22'''
        pass

    def kSnapshot(self):
        '''This is an enum of Type.
Description: 
Value: 470'''
        pass

    def kScalePointManip(self):
        '''This is an enum of Type.
Description: 
Value: 811'''
        pass

    def kClusterFlexor(self):
        '''This is an enum of Type.
Description: 
Value: 299'''
        pass

    def kChecker(self):
        '''This is an enum of Type.
Description: 
Value: 486'''
        pass

    def kPluginHardwareShader(self):
        '''This is an enum of Type.
Description: Custom hardware shader derived from
Value: 870'''
        pass

    def kHandleRotateManip(self):
        '''This is an enum of Type.
Description: 
Value: 216'''
        pass

    def kExplodeNurbsShell(self):
        '''This is an enum of Type.
Description: 
Value: 676'''
        pass

    def kGeometryConstraint(self):
        '''This is an enum of Type.
Description: 
Value: 113'''
        pass

    def kSingleShadingSwitch(self):
        '''This is an enum of Type.
Description: 
Value: 604'''
        pass

    def kRenderGlobals(self):
        '''This is an enum of Type.
Description: 
Value: 511'''
        pass

    def kSubdMapSewMove(self):
        '''This is an enum of Type.
Description: 
Value: 854'''
        pass

    def kTrimWithBoundaries(self):
        '''This is an enum of Type.
Description: 
Value: 912'''
        pass

    def kPluginParticleAttributeMapperNode(self):
        '''This is an enum of Type.
Description: 
Value: 984'''
        pass

    def kCurveFromSubdivFace(self):
        '''This is an enum of Type.
Description: 
Value: 822'''
        pass

    def kPolyToolFeedbackShape(self):
        '''This is an enum of Type.
Description: 
Value: 311'''
        pass

    def kSnow(self):
        '''This is an enum of Type.
Description: 
Value: 503'''
        pass

    def kXsectionSubdivEdit(self):
        '''This is an enum of Type.
Description: 
Value: 799'''
        pass

    def kImageOver(self):
        '''This is an enum of Type.
Description: 
Value: 648'''
        pass

    def kCommEdgePtManip(self):
        '''This is an enum of Type.
Description: 
Value: 596'''
        pass

    def kPolySmooth(self):
        '''This is an enum of Type.
Description: 
Value: 417'''
        pass

    def kCreateSectionManip(self):
        '''This is an enum of Type.
Description: 
Value: 804'''
        pass

    def kLeather(self):
        '''This is an enum of Type.
Description: 
Value: 500'''
        pass

    def kPluginData(self):
        '''This is an enum of Type.
Description: Custom data types derived from
Value: 588'''
        pass

    def kTripleIndexedComponent(self):
        '''This is an enum of Type.
Description: 
Value: 699'''
        pass

    def kObjectTypeFilter(self):
        '''This is an enum of Type.
Description: 
Value: 664'''
        pass

    def kMeshGeom(self):
        '''This is an enum of Type.
Description: 
Value: 296'''
        pass

    def kTurbulence(self):
        '''This is an enum of Type.
Description: 
Value: 261'''
        pass

    def kDynEmitterManip(self):
        '''This is an enum of Type.
Description: 
Value: 705'''
        pass

    def kFileBackground(self):
        '''This is an enum of Type.
Description: 
Value: 25'''
        pass

    def kDropoffManip(self):
        '''This is an enum of Type.
Description: 
Value: 163'''
        pass

    def kHyperLayout(self):
        '''This is an enum of Type.
Description: 
Value: 352'''
        pass

    def kResolution(self):
        '''This is an enum of Type.
Description: 
Value: 514'''
        pass

    def kSplineSolver(self):
        '''This is an enum of Type.
Description: 
Value: 359'''
        pass

    def kPlace3dTexture(self):
        '''This is an enum of Type.
Description: 
Value: 446'''
        pass

    def kBlindDataTemplate(self):
        '''This is an enum of Type.
Description: 
Value: 741'''
        pass

    def kHistorySwitch(self):
        '''This is an enum of Type.
Description: 
Value: 964'''
        pass

    def kPolySphere(self):
        '''This is an enum of Type.
Description: 
Value: 430'''
        pass

    def kBump(self):
        '''This is an enum of Type.
Description: 
Value: 32'''
        pass

    def kCurveFromMeshEdge(self):
        '''This is an enum of Type.
Description: 
Value: 626'''
        pass

    def kForceUpdateManip(self):
        '''This is an enum of Type.
Description: 
Value: 679'''
        pass

    def kBendLattice(self):
        '''This is an enum of Type.
Description: 
Value: 334'''
        pass

    def kHeightField(self):
        '''This is an enum of Type.
Description: 
Value: 900'''
        pass

    def kClipScheduler(self):
        '''This is an enum of Type.
Description: 
Value: 763'''
        pass

    def kReference(self):
        '''This is an enum of Type.
Description: 
Value: 739'''
        pass

    def kNBase(self):
        '''This is an enum of Type.
Description: 
Value: 972'''
        pass

    def kSubdDelFace(self):
        '''This is an enum of Type.
Description: 
Value: 838'''
        pass

    def kAvgCurves(self):
        '''This is an enum of Type.
Description: 
Value: 45'''
        pass

    def kPluginGeometryData(self):
        '''This is an enum of Type.
Description: Custom container for arbitrary Geometry type derived from
Value: 751'''
        pass

    def kBlinnMaterial(self):
        '''This is an enum of Type.
Description: 
Value: 379'''
        pass

    def kSubdivToPoly(self):
        '''This is an enum of Type.
Description: 
Value: 703'''
        pass

    def kPluginObjectSet(self):
        '''This is an enum of Type.
Description: Custom sets (dependency nodes) derived from
Value: 903'''
        pass

    def kParticleAgeMapper(self):
        '''This is an enum of Type.
Description: 
Value: 439'''
        pass

    def kPolyExtrudeFacet(self):
        '''This is an enum of Type.
Description: 
Value: 401'''
        pass

    def kThreePointArcManip(self):
        '''This is an enum of Type.
Description: 
Value: 635'''
        pass

    def kDirectionalLight(self):
        '''This is an enum of Type.
Description: 
Value: 307'''
        pass

    def kFilletCurve(self):
        '''This is an enum of Type.
Description: 
Value: 70'''
        pass

    def kVolumeAxis(self):
        '''This is an enum of Type.
Description: 
Value: 780'''
        pass

    def kNurbsPlane(self):
        '''This is an enum of Type.
Description: 
Value: 79'''
        pass

    def kLodThresholds(self):
        '''This is an enum of Type.
Description: 
Value: 755'''
        pass

    def kDecayRegionCapComponent(self):
        '''This is an enum of Type.
Description: 
Value: 536'''
        pass

    def kEnvCube(self):
        '''This is an enum of Type.
Description: 
Value: 480'''
        pass

    def kPostProcessList(self):
        '''This is an enum of Type.
Description: 
Value: 452'''
        pass

    def kOffsetCos(self):
        '''This is an enum of Type.
Description: 
Value: 81'''
        pass

    def kTrimLocator(self):
        '''This is an enum of Type.
Description: 
Value: 286'''
        pass

    def kPolyUnite(self):
        '''This is an enum of Type.
Description: 
Value: 433'''
        pass

    def kPfxToon(self):
        '''This is an enum of Type.
Description: 
Value: 947'''
        pass

    def kCurveEPComponent(self):
        '''This is an enum of Type.
Description: 
Value: 525'''
        pass

    def kSectionManip(self):
        '''This is an enum of Type.
Description: 
Value: 798'''
        pass

    def kEnvFogMaterial(self):
        '''This is an enum of Type.
Description: 
Value: 371'''
        pass

    def kBulge(self):
        '''This is an enum of Type.
Description: 
Value: 485'''
        pass

    def kRPsolver(self):
        '''This is an enum of Type.
Description: 
Value: 358'''
        pass

    def kData2Float(self):
        '''This is an enum of Type.
Description: 
Value: 581'''
        pass

    def kIkSplineManip(self):
        '''This is an enum of Type.
Description: 
Value: 166'''
        pass

    def kMultiSubVertexComponent(self):
        '''This is an enum of Type.
Description: 
Value: 546'''
        pass

    def kBirailSrf(self):
        '''This is an enum of Type.
Description: 
Value: 49'''
        pass

    def kDynBaseFieldManip(self):
        '''This is an enum of Type.
Description: 
Value: 707'''
        pass

    def kAnisotropy(self):
        '''This is an enum of Type.
Description: 
Value: 608'''
        pass

    def kVectorProduct(self):
        '''This is an enum of Type.
Description: 
Value: 521'''
        pass

    def kExtendSurfaceDistanceManip(self):
        '''This is an enum of Type.
Description: 
Value: 700'''
        pass

    def kSpotLight(self):
        '''This is an enum of Type.
Description: 
Value: 309'''
        pass

    def kPlace2dTexture(self):
        '''This is an enum of Type.
Description: 
Value: 445'''
        pass

    def kLuminance(self):
        '''This is an enum of Type.
Description: 
Value: 374'''
        pass

    def kLightInfo(self):
        '''This is an enum of Type.
Description: 
Value: 368'''
        pass

    def kPolyMoveVertexUV(self):
        '''This is an enum of Type.
Description: 
Value: 412'''
        pass

    def kRenderPassSet(self):
        '''This is an enum of Type.
Description: 
Value: 768'''
        pass

    def kRemapColor(self):
        '''This is an enum of Type.
Description: 
Value: 917'''
        pass

    def kFFblendSrf(self):
        '''This is an enum of Type.
Description: 
Value: 68'''
        pass

    def kPolySplit(self):
        '''This is an enum of Type.
Description: 
Value: 420'''
        pass

    def kSubdivCollapse(self):
        '''This is an enum of Type.
Description: 
Value: 786'''
        pass

    def kMeshVtxFaceComponent(self):
        '''This is an enum of Type.
Description: 
Value: 729'''
        pass

    def kKeyframeDelta(self):
        '''This is an enum of Type.
Description: 
Value: 928'''
        pass

    def kPolyAppendVertex(self):
        '''This is an enum of Type.
Description: 
Value: 777'''
        pass

    def kSubdivData(self):
        '''This is an enum of Type.
Description: 
Value: 792'''
        pass

    def kPolyProj(self):
        '''This is an enum of Type.
Description: 
Value: 415'''
        pass

    def kDeformSine(self):
        '''This is an enum of Type.
Description: 
Value: 615'''
        pass

    def kTextCurves(self):
        '''This is an enum of Type.
Description: 
Value: 104'''
        pass

    def kSuper(self):
        '''This is an enum of Type.
Description: 
Value: 473'''
        pass

    def kTypedAttribute(self):
        '''This is an enum of Type.
Description: 
Value: 562'''
        pass

    def kPointManip(self):
        '''This is an enum of Type.
Description: 
Value: 236'''
        pass

    def kTrsXformManip(self):
        '''This is an enum of Type.
Description: 
Value: 204'''
        pass

    def kOrientationMarker(self):
        '''This is an enum of Type.
Description: 
Value: 283'''
        pass

    def kTowPointOnSurfaceManip(self):
        '''This is an enum of Type.
Description: 
Value: 760'''
        pass

    def kPolyPrimitiveMisc(self):
        '''This is an enum of Type.
Description: 
Value: 956'''
        pass

    def kBlendNodeDouble(self):
        '''This is an enum of Type.
Description: 
Value: 995'''
        pass

    def kPolyMapCut(self):
        '''This is an enum of Type.
Description: 
Value: 402'''
        pass

    def kSurfaceInfo(self):
        '''This is an enum of Type.
Description: 
Value: 103'''
        pass

    def kSubdivReverseFaces(self):
        '''This is an enum of Type.
Description: 
Value: 796'''
        pass

    def kPolyToolFeedbackManip(self):
        '''This is an enum of Type.
Description: 
Value: 1012'''
        pass

    def kToonLineAttributes(self):
        '''This is an enum of Type.
Description: 
Value: 948'''
        pass

    def kPlanarTrimSrf(self):
        '''This is an enum of Type.
Description: 
Value: 83'''
        pass

    def kResultCurveTimeToDistance(self):
        '''This is an enum of Type.
Description: 
Value: 18'''
        pass

    def kFractal(self):
        '''This is an enum of Type.
Description: 
Value: 489'''
        pass

    def kData3Float(self):
        '''This is an enum of Type.
Description: 
Value: 585'''
        pass

    def kDeformWaveManip(self):
        '''This is an enum of Type.
Description: 
Value: 622'''
        pass

    def kPolyChipOff(self):
        '''This is an enum of Type.
Description: 
Value: 393'''
        pass

    def kHyperLayoutDG(self):
        '''This is an enum of Type.
Description: 
Value: 979'''
        pass

    def kMeshFaceVertComponent(self):
        '''This is an enum of Type.
Description: 
Value: 543'''
        pass

    def kDisplayLayer(self):
        '''This is an enum of Type.
Description: 
Value: 717'''
        pass

    def kBlendNodeEnum(self):
        '''This is an enum of Type.
Description: 
Value: 998'''
        pass

    def kSurfaceVarGroup(self):
        '''This is an enum of Type.
Description: 
Value: 118'''
        pass

    def kEnableManip(self):
        '''This is an enum of Type.
Description: 
Value: 136'''
        pass

    def kDeformBend(self):
        '''This is an enum of Type.
Description: 
Value: 611'''
        pass

    def kMatrixAdd(self):
        '''This is an enum of Type.
Description: 
Value: 383'''
        pass

    def kCurveFromSurfaceIso(self):
        '''This is an enum of Type.
Description: 
Value: 61'''
        pass

    def kPolyAutoProjManip(self):
        '''This is an enum of Type.
Description: 
Value: 943'''
        pass

    def kDynNewtonManip(self):
        '''This is an enum of Type.
Description: 
Value: 709'''
        pass

    def kBlinn(self):
        '''This is an enum of Type.
Description: 
Value: 364'''
        pass

    def kPolyDelEdge(self):
        '''This is an enum of Type.
Description: 
Value: 398'''
        pass

    def kLayeredTexture(self):
        '''This is an enum of Type.
Description: 
Value: 785'''
        pass

    def kCylindricalProjectionManip(self):
        '''This is an enum of Type.
Description: 
Value: 131'''
        pass

    def kGeoConnectable(self):
        '''This is an enum of Type.
Description: 
Value: 325'''
        pass

    def kPolyCreaseEdge(self):
        '''This is an enum of Type.
Description: 
Value: 938'''
        pass

    def kRigid(self):
        '''This is an enum of Type.
Description: 
Value: 313'''
        pass

    def kLightLink(self):
        '''This is an enum of Type.
Description: 
Value: 752'''
        pass

    def kBlend(self):
        '''This is an enum of Type.
Description: 
Value: 27'''
        pass

    def kGuide(self):
        '''This is an enum of Type.
Description: 
Value: 349'''
        pass

    def kPolyCutManip(self):
        '''This is an enum of Type.
Description: 
Value: 885'''
        pass

    def kWriteToFrameBuffer(self):
        '''This is an enum of Type.
Description: 
Value: 1014'''
        pass

    def kMatrixMult(self):
        '''This is an enum of Type.
Description: 
Value: 385'''
        pass

    def kPolyCreator(self):
        '''This is an enum of Type.
Description: 
Value: 424'''
        pass

    def kComponentManip(self):
        '''This is an enum of Type.
Description: 
Value: 659'''
        pass

    def kPolyCylProj(self):
        '''This is an enum of Type.
Description: 
Value: 397'''
        pass

    def kAnimLayer(self):
        '''This is an enum of Type.
Description: 
Value: 992'''
        pass

    def kRenderQuality(self):
        '''This is an enum of Type.
Description: 
Value: 513'''
        pass

    def kRenderRect(self):
        '''This is an enum of Type.
Description: 
Value: 276'''
        pass

    def kPolySewEdge(self):
        '''This is an enum of Type.
Description: 
Value: 681'''
        pass

    def kImageColorCorrect(self):
        '''This is an enum of Type.
Description: 
Value: 650'''
        pass

    def kSubdivCVComponent(self):
        '''This is an enum of Type.
Description: 
Value: 686'''
        pass

    def kPolySelectEditFeedbackManip(self):
        '''This is an enum of Type.
Description: 
Value: 1013'''
        pass

    def kJiggleDeformer(self):
        '''This is an enum of Type.
Description: 
Value: 841'''
        pass

    def kParticleSamplerInfo(self):
        '''This is an enum of Type.
Description: 
Value: 787'''
        pass

    def kBrownian(self):
        '''This is an enum of Type.
Description: 
Value: 496'''
        pass

    def kLeastSquares(self):
        '''This is an enum of Type.
Description: 
Value: 369'''
        pass

    def kFluidEmitter(self):
        '''This is an enum of Type.
Description: 
Value: 899'''
        pass

    def kSubdCleanTopology(self):
        '''This is an enum of Type.
Description: 
Value: 873'''
        pass

    def kLocator(self):
        '''This is an enum of Type.
Description: 
Value: 280'''
        pass

    def kModifyEdgeCrvManip(self):
        '''This is an enum of Type.
Description: 
Value: 809'''
        pass

    def kBlendNodeAdditiveScale(self):
        '''This is an enum of Type.
Description: 
Value: 1004'''
        pass

    def kBlendNodeDoubleLinear(self):
        '''This is an enum of Type.
Description: 
Value: 997'''
        pass

    def kBlendNodeBoolean(self):
        '''This is an enum of Type.
Description: 
Value: 994'''
        pass

    def kCacheTrack(self):
        '''This is an enum of Type.
Description: 
Value: 975'''
        pass

    def kPolyNormal(self):
        '''This is an enum of Type.
Description: 
Value: 413'''
        pass

    def kHardwareReflectionMap(self):
        '''This is an enum of Type.
Description: 
Value: 866'''
        pass

    def kFluid(self):
        '''This is an enum of Type.
Description: 
Value: 893'''
        pass

    def kPoleVectorConstraint(self):
        '''This is an enum of Type.
Description: 
Value: 242'''
        pass

    def kPolyMergeEdge(self):
        '''This is an enum of Type.
Description: 
Value: 405'''
        pass

    def kPlanarProjectionManip(self):
        '''This is an enum of Type.
Description: 
Value: 207'''
        pass

    def kImageNetSrc(self):
        '''This is an enum of Type.
Description: 
Value: 642'''
        pass

    def kShaderList(self):
        '''This is an enum of Type.
Description: 
Value: 464'''
        pass

    def kSubdivEdgeComponent(self):
        '''This is an enum of Type.
Description: 
Value: 687'''
        pass

    def kMeshComponent(self):
        '''This is an enum of Type.
Description: 
Value: 538'''
        pass

    def kCamera(self):
        '''This is an enum of Type.
Description: 
Value: 249'''
        pass

    def kDynamicsController(self):
        '''This is an enum of Type.
Description: 
Value: 324'''
        pass

    def kNonDagSelectionItem(self):
        '''This is an enum of Type.
Description: 
Value: 551'''
        pass

    def kOffsetCurve(self):
        '''This is an enum of Type.
Description: 
Value: 82'''
        pass

    def kPluginImagePlaneNode(self):
        '''This is an enum of Type.
Description: Custom Image Plane classes derived from
Value: 980'''
        pass

    def kSymmetryLocator(self):
        '''This is an enum of Type.
Description: 
Value: 813'''
        pass

    def kAttribute2Long(self):
        '''This is an enum of Type.
Description: Used for backward compatibility.
Value: 734'''
        pass

    def kNParticle(self):
        '''This is an enum of Type.
Description: 
Value: 982'''
        pass

    def kGeometryVarGroup(self):
        '''This is an enum of Type.
Description: 
Value: 114'''
        pass

    def kFourByFourMatrix(self):
        '''This is an enum of Type.
Description: 
Value: 759'''
        pass

    def kDistanceManip(self):
        '''This is an enum of Type.
Description: 
Value: 624'''
        pass

    def kPolyMoveUV(self):
        '''This is an enum of Type.
Description: 
Value: 410'''
        pass

    def kCloseCurve(self):
        '''This is an enum of Type.
Description: 
Value: 55'''
        pass

    def kBlendNodeInt32(self):
        '''This is an enum of Type.
Description: 
Value: 1003'''
        pass

    def kPolyMergeUV(self):
        '''This is an enum of Type.
Description: 
Value: 889'''
        pass

    def kSCsolver(self):
        '''This is an enum of Type.
Description: 
Value: 357'''
        pass

    def kChainToSpline(self):
        '''This is an enum of Type.
Description: 
Value: 35'''
        pass

    def kFreePointManip(self):
        '''This is an enum of Type.
Description: 
Value: 133'''
        pass

    def kSubdAutoProj(self):
        '''This is an enum of Type.
Description: 
Value: 857'''
        pass

    def kAverageCurveManip(self):
        '''This is an enum of Type.
Description: 
Value: 149'''
        pass

    def kPolyVertexNormalManip(self):
        '''This is an enum of Type.
Description: 
Value: 197'''
        pass

    def kGeometryFilt(self):
        '''This is an enum of Type.
Description: 
Value: 333'''
        pass

    def kPointConstraint(self):
        '''This is an enum of Type.
Description: 
Value: 240'''
        pass

    def kCrossSectionManager(self):
        '''This is an enum of Type.
Description: 
Value: 803'''
        pass

    def kNIdData(self):
        '''This is an enum of Type.
Description: 
Value: 1007'''
        pass

    def kRigidSolver(self):
        '''This is an enum of Type.
Description: 
Value: 458'''
        pass

    def kDeformFlare(self):
        '''This is an enum of Type.
Description: 
Value: 614'''
        pass

    def kDeformFlareManip(self):
        '''This is an enum of Type.
Description: 
Value: 620'''
        pass

    def kTranslateLimitsManip(self):
        '''This is an enum of Type.
Description: 
Value: 226'''
        pass

    def kPlugin(self):
        '''This is an enum of Type.
Description: Custom Plug-in.
Value: 569'''
        pass

    def kPolyPrism(self):
        '''This is an enum of Type.
Description: 
Value: 944'''
        pass

    def kPfxGeometry(self):
        '''This is an enum of Type.
Description: 
Value: 924'''
        pass

    def kSelectionItem(self):
        '''This is an enum of Type.
Description: 
Value: 549'''
        pass

    def kDynTurbulenceManip(self):
        '''This is an enum of Type.
Description: 
Value: 710'''
        pass

    def kLatticeComponent(self):
        '''This is an enum of Type.
Description: 
Value: 534'''
        pass

    def kTextureEnv(self):
        '''This is an enum of Type.
Description: 
Value: 478'''
        pass

    def kSubdAddTopology(self):
        '''This is an enum of Type.
Description: 
Value: 872'''
        pass

    def kMentalRayTexture(self):
        '''This is an enum of Type.
Description: 
Value: 921'''
        pass

    def kPluginEmitterNode(self):
        '''This is an enum of Type.
Description: Custom dependency graph node representing an emitter derived from
Value: 715'''
        pass

    def kBulgeLattice(self):
        '''This is an enum of Type.
Description: 
Value: 336'''
        pass

    def kClampColor(self):
        '''This is an enum of Type.
Description: 
Value: 39'''
        pass

    def kRenderSphere(self):
        '''This is an enum of Type.
Description: 
Value: 297'''
        pass

    def kRenderGlobalsList(self):
        '''This is an enum of Type.
Description: 
Value: 512'''
        pass

    def kMeshMapComponent(self):
        '''This is an enum of Type.
Description: 
Value: 797'''
        pass

    def kNonExtendedLight(self):
        '''This is an enum of Type.
Description: 
Value: 306'''
        pass

    def kWrapFilter(self):
        '''This is an enum of Type.
Description: 
Value: 728'''
        pass

    def kPolyMergeFacet(self):
        '''This is an enum of Type.
Description: 
Value: 406'''
        pass

    def kNurbsToSubdiv(self):
        '''This is an enum of Type.
Description: 
Value: 744'''
        pass

    def kExpression(self):
        '''This is an enum of Type.
Description: 
Value: 326'''
        pass

    def kNurbsSurface(self):
        '''This is an enum of Type.
Description: 
Value: 293'''
        pass

    def kStucco(self):
        '''This is an enum of Type.
Description: 
Value: 505'''
        pass

    def kGeometryData(self):
        '''This is an enum of Type.
Description: 
Value: 696'''
        pass

    def kPolyPokeManip(self):
        '''This is an enum of Type.
Description: 
Value: 886'''
        pass

    def kUnitConversion(self):
        '''This is an enum of Type.
Description: 
Value: 517'''
        pass

    def kCurveVarGroup(self):
        '''This is an enum of Type.
Description: 
Value: 116'''
        pass

    def kPolyDuplicateEdge(self):
        '''This is an enum of Type.
Description: 
Value: 949'''
        pass

    def kSprite(self):
        '''This is an enum of Type.
Description: 
Value: 291'''
        pass

    def kClip(self):
        '''This is an enum of Type.
Description: 
Value: 790'''
        pass

    def kMoveVertexManip(self):
        '''This is an enum of Type.
Description: 
Value: 747'''
        pass

    def kCharacterMappingData(self):
        '''This is an enum of Type.
Description: 
Value: 726'''
        pass

    def kParamDimension(self):
        '''This is an enum of Type.
Description: 
Value: 274'''
        pass

    def kKeyframeDeltaInfType(self):
        '''This is an enum of Type.
Description: 
Value: 933'''
        pass

    def kUseBackground(self):
        '''This is an enum of Type.
Description: 
Value: 519'''
        pass

    def kCurveNormalizerAngle(self):
        '''This is an enum of Type.
Description: 
Value: 977'''
        pass

    def kMaterialInfo(self):
        '''This is an enum of Type.
Description: 
Value: 382'''
        pass

    def kFreePointTriadManip(self):
        '''This is an enum of Type.
Description: 
Value: 137'''
        pass

    def kReverseSurface(self):
        '''This is an enum of Type.
Description: 
Value: 93'''
        pass

    def kAttribute2Double(self):
        '''This is an enum of Type.
Description: 
Value: 731'''
        pass

    def kCreateEPManip(self):
        '''This is an enum of Type.
Description: 
Value: 158'''
        pass

    def kImageDisplay(self):
        '''This is an enum of Type.
Description: 
Value: 654'''
        pass

    def kCreateCVManip(self):
        '''This is an enum of Type.
Description: 
Value: 157'''
        pass

    def kUnknown(self):
        '''This is an enum of Type.
Description: 
Value: 520'''
        pass

    def kPolyPyramid(self):
        '''This is an enum of Type.
Description: 
Value: 945'''
        pass

    def kCurveFromSubdivEdge(self):
        '''This is an enum of Type.
Description: 
Value: 816'''
        pass

    def kSubdExtrudeFace(self):
        '''This is an enum of Type.
Description: 
Value: 819'''
        pass

    def kDummy(self):
        '''This is an enum of Type.
Description: 
Value: 253'''
        pass

    def kGeometric(self):
        '''This is an enum of Type.
Description: 
Value: 264'''
        pass

    def kPolySubdFacet(self):
        '''This is an enum of Type.
Description: 
Value: 422'''
        pass

    def kSphere(self):
        '''This is an enum of Type.
Description: 
Value: 99'''
        pass

    def kOrientConstraint(self):
        '''This is an enum of Type.
Description: 
Value: 239'''
        pass

    def kPhong(self):
        '''This is an enum of Type.
Description: 
Value: 365'''
        pass

    def kCacheBase(self):
        '''This is an enum of Type.
Description: 
Value: 973'''
        pass

    def kNurbsSurfaceGeom(self):
        '''This is an enum of Type.
Description: 
Value: 294'''
        pass

    def kTranslateUVManip(self):
        '''This is an enum of Type.
Description: 
Value: 213'''
        pass

    def kGammaCorrect(self):
        '''This is an enum of Type.
Description: 
Value: 332'''
        pass

    def kItemList(self):
        '''This is an enum of Type.
Description: 
Value: 552'''
        pass

    def kNoise(self):
        '''This is an enum of Type.
Description: 
Value: 859'''
        pass

    def kAnimCurve(self):
        '''This is an enum of Type.
Description: 
Value: 7'''
        pass

    def kIntersectSurface(self):
        '''This is an enum of Type.
Description: 
Value: 77'''
        pass

    def kShaderGlow(self):
        '''This is an enum of Type.
Description: 
Value: 463'''
        pass

    def kPluginFieldNode(self):
        '''This is an enum of Type.
Description: Custom dependency graph node representing a field derived from
Value: 714'''
        pass

    def kDispatchCompute(self):
        '''This is an enum of Type.
Description: 
Value: 318'''
        pass

    def kPolyPlatonicSolid(self):
        '''This is an enum of Type.
Description: 
Value: 957'''
        pass

    def kMatrixWtAdd(self):
        '''This is an enum of Type.
Description: 
Value: 387'''
        pass

    def kPluginDeformerNode(self):
        '''This is an enum of Type.
Description: Custom deformer node derived from
Value: 601'''
        pass

    def kExtendCurve(self):
        '''This is an enum of Type.
Description: 
Value: 65'''
        pass

    def kSubVertexComponent(self):
        '''This is an enum of Type.
Description: 
Value: 545'''
        pass

    def kDistanceBetween(self):
        '''This is an enum of Type.
Description: 
Value: 321'''
        pass

    def kMotionPath(self):
        '''This is an enum of Type.
Description: 
Value: 434'''
        pass

    def kRotateUVManip2D(self):
        '''This is an enum of Type.
Description: 
Value: 691'''
        pass

    def kFixedLineManip(self):
        '''This is an enum of Type.
Description: 
Value: 233'''
        pass

    def kBevelManip(self):
        '''This is an enum of Type.
Description: 
Value: 151'''
        pass

    def kBlendNodeFloatLinear(self):
        '''This is an enum of Type.
Description: 
Value: 1001'''
        pass

    def kAttribute3Float(self):
        '''This is an enum of Type.
Description: 
Value: 736'''
        pass

    def kAsset(self):
        '''This is an enum of Type.
Description: 
Value: 990'''
        pass

    def kParticle(self):
        '''This is an enum of Type.
Description: 
Value: 310'''
        pass

    def kOffsetSurfaceManip(self):
        '''This is an enum of Type.
Description: 
Value: 638'''
        pass

    def kCreateColorSet(self):
        '''This is an enum of Type.
Description: 
Value: 720'''
        pass

    def kPointOnCurveInfo(self):
        '''This is an enum of Type.
Description: 
Value: 84'''
        pass

    def kModifyEdgeManip(self):
        '''This is an enum of Type.
Description: 
Value: 810'''
        pass

    def kPolyAverageVertex(self):
        '''This is an enum of Type.
Description: 
Value: 830'''
        pass

    def kStrokeGlobals(self):
        '''This is an enum of Type.
Description: 
Value: 750'''
        pass

    def kNumericData(self):
        '''This is an enum of Type.
Description: 
Value: 579'''
        pass

    def kTowPointOnCurveManip(self):
        '''This is an enum of Type.
Description: 
Value: 209'''
        pass

    def kAnimCurveUnitlessToDistance(self):
        '''This is an enum of Type.
Description: 
Value: 13'''
        pass

    def kPolyHelix(self):
        '''This is an enum of Type.
Description: 
Value: 962'''
        pass

    def kWood(self):
        '''This is an enum of Type.
Description: 
Value: 507'''
        pass

    def kPolyMoveVertexManip(self):
        '''This is an enum of Type.
Description: 
Value: 196'''
        pass

    def kPluginSpringNode(self):
        '''This is an enum of Type.
Description: Custom dependency graph node representing a spring derived from
Value: 716'''
        pass

    def kMeshVarGroup(self):
        '''This is an enum of Type.
Description: 
Value: 117'''
        pass

    def kImageMotionBlur(self):
        '''This is an enum of Type.
Description: 
Value: 656'''
        pass

    def kGeometryOnLineManip(self):
        '''This is an enum of Type.
Description: 
Value: 142'''
        pass

    def kSubdPlanProj(self):
        '''This is an enum of Type.
Description: 
Value: 862'''
        pass

    def kMaterialFacade(self):
        '''This is an enum of Type.
Description: 
Value: 951'''
        pass

    def kRecord(self):
        '''This is an enum of Type.
Description: 
Value: 454'''
        pass

    def kClosestPointOnSurface(self):
        '''This is an enum of Type.
Description: 
Value: 56'''
        pass

    def kLightList(self):
        '''This is an enum of Type.
Description: 
Value: 372'''
        pass

    def kProjectionUVManip(self):
        '''This is an enum of Type.
Description: 
Value: 175'''
        pass

    def kParentConstraint(self):
        '''This is an enum of Type.
Description: 
Value: 241'''
        pass

    def kLightProjectionGeometry(self):
        '''This is an enum of Type.
Description: 
Value: 234'''
        pass

    def kBlendWeighted(self):
        '''This is an enum of Type.
Description: 
Value: 29'''
        pass

    def kGravity(self):
        '''This is an enum of Type.
Description: 
Value: 258'''
        pass

    def kFilterEuler(self):
        '''This is an enum of Type.
Description: 
Value: 330'''
        pass

    def kUntrim(self):
        '''This is an enum of Type.
Description: 
Value: 106'''
        pass

    def kSubdTweakUV(self):
        '''This is an enum of Type.
Description: 
Value: 851'''
        pass

    def kFluidGeom(self):
        '''This is an enum of Type.
Description: 
Value: 894'''
        pass

    def kCurveFromSurface(self):
        '''This is an enum of Type.
Description: 
Value: 58'''
        pass

    def kSurfaceFaceComponent(self):
        '''This is an enum of Type.
Description: 
Value: 762'''
        pass

    def kPolyPipe(self):
        '''This is an enum of Type.
Description: 
Value: 958'''
        pass

    def kClusterFilter(self):
        '''This is an enum of Type.
Description: 
Value: 343'''
        pass

    def kDOF(self):
        '''This is an enum of Type.
Description: 
Value: 322'''
        pass

    def kAxesActionManip(self):
        '''This is an enum of Type.
Description: 
Value: 124'''
        pass

    def kAnimCurveTimeToDistance(self):
        '''This is an enum of Type.
Description: 
Value: 9'''
        pass

    def kDagNode(self):
        '''This is an enum of Type.
Description: 
Value: 107'''
        pass

    def kStringData(self):
        '''This is an enum of Type.
Description: 
Value: 591'''
        pass

    def kPolyMoveEdge(self):
        '''This is an enum of Type.
Description: 
Value: 407'''
        pass

    def kTransformGeometry(self):
        '''This is an enum of Type.
Description: 
Value: 595'''
        pass

    def kTexLatticeDeformManip(self):
        '''This is an enum of Type.
Description: 
Value: 199'''
        pass

    def kPolySubdEdge(self):
        '''This is an enum of Type.
Description: 
Value: 421'''
        pass

    def kCacheBlend(self):
        '''This is an enum of Type.
Description: 
Value: 974'''
        pass

    def kPolyPlanProj(self):
        '''This is an enum of Type.
Description: 
Value: 414'''
        pass

    def kSurfaceLuminance(self):
        '''This is an enum of Type.
Description: 
Value: 475'''
        pass

    def kUInt64ArrayData(self):
        '''This is an enum of Type.
Description: 
Value: 794'''
        pass

    def kMergeVertsToolManip(self):
        '''This is an enum of Type.
Description: 
Value: 1010'''
        pass

    def kOldGeometryConstraint(self):
        '''This is an enum of Type.
Description: 
Value: 437'''
        pass

    def kMarble(self):
        '''This is an enum of Type.
Description: 
Value: 501'''
        pass

    def kPolyReduce(self):
        '''This is an enum of Type.
Description: 
Value: 754'''
        pass

    def kFileTexture(self):
        '''This is an enum of Type.
Description: 
Value: 488'''
        pass

    def kPolySphProj(self):
        '''This is an enum of Type.
Description: 
Value: 419'''
        pass

    def kSketchPlane(self):
        '''This is an enum of Type.
Description: 
Value: 288'''
        pass

    def kAvgSurfacePoints(self):
        '''This is an enum of Type.
Description: 
Value: 46'''
        pass

    def kHyperView(self):
        '''This is an enum of Type.
Description: 
Value: 353'''
        pass

    def kMountain(self):
        '''This is an enum of Type.
Description: 
Value: 491'''
        pass

    def kKeyframeDeltaScale(self):
        '''This is an enum of Type.
Description: 
Value: 930'''
        pass

    def kAnimCurveUnitlessToUnitless(self):
        '''This is an enum of Type.
Description: 
Value: 15'''
        pass

    def kIkSolver(self):
        '''This is an enum of Type.
Description: 
Value: 354'''
        pass

    def kSubdHierBlind(self):
        '''This is an enum of Type.
Description: 
Value: 782'''
        pass

    def kSurfaceEdManip(self):
        '''This is an enum of Type.
Description: 
Value: 761'''
        pass

    def kStringArrayData(self):
        '''This is an enum of Type.
Description: 
Value: 592'''
        pass

    def kMeshVertComponent(self):
        '''This is an enum of Type.
Description: 
Value: 542'''
        pass

    def kReverseSurfaceManip(self):
        '''This is an enum of Type.
Description: 
Value: 183'''
        pass

    def kOrientationLocator(self):
        '''This is an enum of Type.
Description: 
Value: 285'''
        pass

    def kProjectTangent(self):
        '''This is an enum of Type.
Description: 
Value: 88'''
        pass

    def kDropoffLocator(self):
        '''This is an enum of Type.
Description: 
Value: 281'''
        pass

    def kMCsolver(self):
        '''This is an enum of Type.
Description: 
Value: 355'''
        pass

    def kCenterManip(self):
        '''This is an enum of Type.
Description: 
Value: 134'''
        pass

    def kContrast(self):
        '''This is an enum of Type.
Description: 
Value: 38'''
        pass

    def kComponent(self):
        '''This is an enum of Type.
Description: 
Value: 523'''
        pass

    def kCameraManip(self):
        '''This is an enum of Type.
Description: 
Value: 154'''
        pass

    def kMatrixFloatData(self):
        '''This is an enum of Type.
Description: 
Value: 657'''
        pass

    def kTextureManip3D(self):
        '''This is an enum of Type.
Description: 
Value: 223'''
        pass

    def kRebuildSurface(self):
        '''This is an enum of Type.
Description: 
Value: 91'''
        pass

    def kPolyProjectionManip(self):
        '''This is an enum of Type.
Description: 
Value: 174'''
        pass

    def kAmbientLight(self):
        '''This is an enum of Type.
Description: 
Value: 302'''
        pass

    def kCharacterOffset(self):
        '''This is an enum of Type.
Description: 
Value: 673'''
        pass

    def kInsertKnotSrf(self):
        '''This is an enum of Type.
Description: 
Value: 76'''
        pass

    def kInvalid(self):
        '''This is an enum of Type.
Description: 
Value: 0'''
        pass

    def kConstraint(self):
        '''This is an enum of Type.
Description: 
Value: 911'''
        pass

    def kNurbsCube(self):
        '''This is an enum of Type.
Description: 
Value: 80'''
        pass

    def kStringShadingSwitch(self):
        '''This is an enum of Type.
Description: 
Value: 897'''
        pass

    def kSfRevolveManip(self):
        '''This is an enum of Type.
Description: 
Value: 821'''
        pass

    def kPolySmoothProxy(self):
        '''This is an enum of Type.
Description: 
Value: 923'''
        pass

    def kPolyColorPerVertex(self):
        '''This is an enum of Type.
Description: 
Value: 719'''
        pass

    def kWriteToDepthBuffer(self):
        '''This is an enum of Type.
Description: 
Value: 1017'''
        pass

    def kGlobalStitch(self):
        '''This is an enum of Type.
Description: 
Value: 685'''
        pass

    def kGuideLine(self):
        '''This is an enum of Type.
Description: 
Value: 300'''
        pass

    def kEditCurve(self):
        '''This is an enum of Type.
Description: 
Value: 801'''
        pass

    def kAttribute4Double(self):
        '''This is an enum of Type.
Description: 
Value: 860'''
        pass

    def kObjectNameFilter(self):
        '''This is an enum of Type.
Description: 
Value: 663'''
        pass

    def kNurbsSurfaceData(self):
        '''This is an enum of Type.
Description: 
Value: 577'''
        pass

    def kPolyTweakUV(self):
        '''This is an enum of Type.
Description: 
Value: 693'''
        pass

    def kResultCurveTimeToAngular(self):
        '''This is an enum of Type.
Description: 
Value: 17'''
        pass

    def kIkSystem(self):
        '''This is an enum of Type.
Description: 
Value: 360'''
        pass

    def kPolyAutoProj(self):
        '''This is an enum of Type.
Description: 
Value: 831'''
        pass

    def kCurve(self):
        '''This is an enum of Type.
Description: 
Value: 265'''
        pass

    def kDoubleAngleAttribute(self):
        '''This is an enum of Type.
Description: 
Value: 555'''
        pass

    def kPolyExtrudeEdge(self):
        '''This is an enum of Type.
Description: 
Value: 774'''
        pass

    def kSubdCloseBorder(self):
        '''This is an enum of Type.
Description: 
Value: 844'''
        pass

    def kPolyMoveUVManip(self):
        '''This is an enum of Type.
Description: 
Value: 193'''
        pass

    def kHikFloorContactMarker(self):
        '''This is an enum of Type.
Description: 
Value: 959'''
        pass

    def kBlendColorSet(self):
        '''This is an enum of Type.
Description: 
Value: 723'''
        pass

    def kPointOnSurfaceManip(self):
        '''This is an enum of Type.
Description: 
Value: 212'''
        pass

    def kHikGroundPlane(self):
        '''This is an enum of Type.
Description: 
Value: 960'''
        pass

    def kTrsTransManip(self):
        '''This is an enum of Type.
Description: 
Value: 202'''
        pass

    def kPolySplitEdge(self):
        '''This is an enum of Type.
Description: 
Value: 795'''
        pass

    def kObjectFilter(self):
        '''This is an enum of Type.
Description: 
Value: 661'''
        pass

    def kSubdiv(self):
        '''This is an enum of Type.
Description: 
Value: 669'''
        pass

    def kPolyQuad(self):
        '''This is an enum of Type.
Description: 
Value: 416'''
        pass

    def kCurveCVComponent(self):
        '''This is an enum of Type.
Description: 
Value: 524'''
        pass

    def kBlendColors(self):
        '''This is an enum of Type.
Description: 
Value: 31'''
        pass

    def kArcLength(self):
        '''This is an enum of Type.
Description: 
Value: 272'''
        pass

    def kPolyColorDel(self):
        '''This is an enum of Type.
Description: 
Value: 725'''
        pass

    def kNumericAttribute(self):
        '''This is an enum of Type.
Description: 
Value: 554'''
        pass

    def kRevolveManip(self):
        '''This is an enum of Type.
Description: 
Value: 184'''
        pass

    def kAnimBlendInOut(self):
        '''This is an enum of Type.
Description: 
Value: 776'''
        pass

    def kSubdMergeVert(self):
        '''This is an enum of Type.
Description: 
Value: 845'''
        pass

    def kReverseCrvManip(self):
        '''This is an enum of Type.
Description: 
Value: 182'''
        pass

    def kData3Long(self):
        '''This is an enum of Type.
Description: Used for backward compatibility.
Value: 586'''
        pass

    def kObjectBinFilter(self):
        '''This is an enum of Type.
Description: 
Value: 922'''
        pass

    def kRigidConstraint(self):
        '''This is an enum of Type.
Description: 
Value: 312'''
        pass

    def kDetachCurve(self):
        '''This is an enum of Type.
Description: 
Value: 63'''
        pass

    def kSurface(self):
        '''This is an enum of Type.
Description: 
Value: 292'''
        pass

    def kBase(self):
        '''This is an enum of Type.
Description: 
Value: 1'''
        pass

    def kImplicitSphere(self):
        '''This is an enum of Type.
Description: 
Value: 875'''
        pass

    def kNComponent(self):
        '''This is an enum of Type.
Description: 
Value: 968'''
        pass

    def kStencil(self):
        '''This is an enum of Type.
Description: 
Value: 493'''
        pass

    def kFloatLinearAttribute(self):
        '''This is an enum of Type.
Description: 
Value: 558'''
        pass

    def kSubCurve(self):
        '''This is an enum of Type.
Description: 
Value: 102'''
        pass

    def kCurveInfo(self):
        '''This is an enum of Type.
Description: 
Value: 62'''
        pass

    def kStitchSrfManip(self):
        '''This is an enum of Type.
Description: 
Value: 678'''
        pass

    def kPrecompExport(self):
        '''This is an enum of Type.
Description: 
Value: 772'''
        pass

    def kPointOnSurfaceInfo(self):
        '''This is an enum of Type.
Description: 
Value: 85'''
        pass

    def kKeyframeDeltaAddRemove(self):
        '''This is an enum of Type.
Description: 
Value: 931'''
        pass

    def kLightFogMaterial(self):
        '''This is an enum of Type.
Description: 
Value: 370'''
        pass

    def kExtendCurveDistanceManip(self):
        '''This is an enum of Type.
Description: 
Value: 164'''
        pass

    def kCameraView(self):
        '''This is an enum of Type.
Description: 
Value: 34'''
        pass

    def kMakeGroup(self):
        '''This is an enum of Type.
Description: 
Value: 375'''
        pass

    def kImageDiff(self):
        '''This is an enum of Type.
Description: 
Value: 646'''
        pass

    def kPolyCreateToolManip(self):
        '''This is an enum of Type.
Description: 
Value: 140'''
        pass

    def kDrag(self):
        '''This is an enum of Type.
Description: 
Value: 257'''
        pass

    def kKeyframeDeltaWeighted(self):
        '''This is an enum of Type.
Description: 
Value: 935'''
        pass

    def kInsertKnotCrv(self):
        '''This is an enum of Type.
Description: 
Value: 75'''
        pass

    def kPrimitive(self):
        '''This is an enum of Type.
Description: 
Value: 86'''
        pass

    def kParticleColorMapper(self):
        '''This is an enum of Type.
Description: 
Value: 441'''
        pass

    def kKeyframeDeltaBreakdown(self):
        '''This is an enum of Type.
Description: 
Value: 936'''
        pass

    def kShapeFragment(self):
        '''This is an enum of Type.
Description: 
Value: 467'''
        pass

    def kProjectionMultiManip(self):
        '''This is an enum of Type.
Description: 
Value: 176'''
        pass

    def kEnvSphere(self):
        '''This is an enum of Type.
Description: 
Value: 483'''
        pass

    def kCloud(self):
        '''This is an enum of Type.
Description: 
Value: 497'''
        pass

    def kStoryBoard(self):
        '''This is an enum of Type.
Description: 
Value: 471'''
        pass

    def kFacade(self):
        '''This is an enum of Type.
Description: 
Value: 950'''
        pass

    def kSimpleVolumeShader(self):
        '''This is an enum of Type.
Description: 
Value: 468'''
        pass

    def kPolyCollapseEdge(self):
        '''This is an enum of Type.
Description: 
Value: 395'''
        pass

    def kNormalConstraint(self):
        '''This is an enum of Type.
Description: 
Value: 238'''
        pass

    def kLatticeGeom(self):
        '''This is an enum of Type.
Description: 
Value: 279'''
        pass

    def kEnvSky(self):
        '''This is an enum of Type.
Description: 
Value: 482'''
        pass

    def kFFD(self):
        '''This is an enum of Type.
Description: 
Value: 337'''
        pass

    def kCommEdgeSegmentManip(self):
        '''This is an enum of Type.
Description: 
Value: 598'''
        pass

    def kSubdMappingManip(self):
        '''This is an enum of Type.
Description: 
Value: 865'''
        pass

    def kNurbsSquare(self):
        '''This is an enum of Type.
Description: 
Value: 607'''
        pass

    def kWriteToVectorBuffer(self):
        '''This is an enum of Type.
Description: 
Value: 1016'''
        pass

    def kSculpt(self):
        '''This is an enum of Type.
Description: 
Value: 340'''
        pass

    def kProjectCurve(self):
        '''This is an enum of Type.
Description: 
Value: 87'''
        pass

    def kSet(self):
        '''This is an enum of Type.
Description: 
Value: 459'''
        pass

    def kPluginShape(self):
        '''This is an enum of Type.
Description: Custom shapes (dependency nodes) derived from
Value: 695'''
        pass

    def kCommCornerManip(self):
        '''This is an enum of Type.
Description: 
Value: 599'''
        pass

    def kTriadManip(self):
        '''This is an enum of Type.
Description: 
Value: 237'''
        pass

    def kVectorArrayData(self):
        '''This is an enum of Type.
Description: 
Value: 593'''
        pass

    def kNurbsCircular3PtArc(self):
        '''This is an enum of Type.
Description: 
Value: 628'''
        pass

    def kSymmetryMapVector(self):
        '''This is an enum of Type.
Description: 
Value: 814'''
        pass

    def kAttribute2Short(self):
        '''This is an enum of Type.
Description: 
Value: 733'''
        pass

    def kRenderBox(self):
        '''This is an enum of Type.
Description: 
Value: 848'''
        pass

    def kRadial(self):
        '''This is an enum of Type.
Description: 
Value: 260'''
        pass

    def kSubdivGeom(self):
        '''This is an enum of Type.
Description: 
Value: 793'''
        pass

    def kCreate(self):
        '''This is an enum of Type.
Description: 
Value: 40'''
        pass

    def kCubicProjectionManip(self):
        '''This is an enum of Type.
Description: 
Value: 130'''
        pass

    def kFilterSimplify(self):
        '''This is an enum of Type.
Description: 
Value: 331'''
        pass

    def kResultCurveTimeToTime(self):
        '''This is an enum of Type.
Description: 
Value: 19'''
        pass

    def kDynamicConstraint(self):
        '''This is an enum of Type.
Description: 
Value: 967'''
        pass

    def kBevelPlus(self):
        '''This is an enum of Type.
Description: 
Value: 879'''
        pass

    def kRemapValue(self):
        '''This is an enum of Type.
Description: 
Value: 916'''
        pass

    def kTextManip(self):
        '''This is an enum of Type.
Description: 
Value: 907'''
        pass

    def kCrater(self):
        '''This is an enum of Type.
Description: 
Value: 498'''
        pass

    def kBinaryData(self):
        '''This is an enum of Type.
Description: 
Value: 730'''
        pass

    def kPolyTorus(self):
        '''This is an enum of Type.
Description: 
Value: 431'''
        pass

    def kImageUnder(self):
        '''This is an enum of Type.
Description: 
Value: 649'''
        pass

    def kStyleCurve(self):
        '''This is an enum of Type.
Description: 
Value: 880'''
        pass

    def kPhongMaterial(self):
        '''This is an enum of Type.
Description: 
Value: 380'''
        pass

    def kLineModifier(self):
        '''This is an enum of Type.
Description: 
Value: 954'''
        pass

    def kPolyTransfer(self):
        '''This is an enum of Type.
Description: 
Value: 829'''
        pass

    def kNamedObject(self):
        '''This is an enum of Type.
Description: 
Value: 2'''
        pass

    def kDeformWave(self):
        '''This is an enum of Type.
Description: 
Value: 616'''
        pass

    def kHsvToRgb(self):
        '''This is an enum of Type.
Description: 
Value: 350'''
        pass

    def kDofManip(self):
        '''This is an enum of Type.
Description: 
Value: 162'''
        pass

    def kImageRender(self):
        '''This is an enum of Type.
Description: 
Value: 644'''
        pass

    def kAreaLight(self):
        '''This is an enum of Type.
Description: 
Value: 304'''
        pass

    def kResultCurveTimeToUnitless(self):
        '''This is an enum of Type.
Description: 
Value: 20'''
        pass

    def kCluster(self):
        '''This is an enum of Type.
Description: 
Value: 250'''
        pass

    def kSubdivToNurbs(self):
        '''This is an enum of Type.
Description: 
Value: 800'''
        pass

    def kPolyWedgeFace(self):
        '''This is an enum of Type.
Description: 
Value: 883'''
        pass

    def kStitchAsNurbsShell(self):
        '''This is an enum of Type.
Description: 
Value: 675'''
        pass

    def kScriptManip(self):
        '''This is an enum of Type.
Description: 
Value: 221'''
        pass

    def kPolySmoothFacet(self):
        '''This is an enum of Type.
Description: 
Value: 683'''
        pass

    def kPolyStraightenUVBorder(self):
        '''This is an enum of Type.
Description: 
Value: 890'''
        pass

    def kMotionPathManip(self):
        '''This is an enum of Type.
Description: 
Value: 170'''
        pass

    def kIsoparmComponent(self):
        '''This is an enum of Type.
Description: 
Value: 528'''
        pass

    def kNewton(self):
        '''This is an enum of Type.
Description: 
Value: 259'''
        pass

    def kPolyEdgeToCurve(self):
        '''This is an enum of Type.
Description: 
Value: 991'''
        pass

    def kAvgNurbsSurfacePoints(self):
        '''This is an enum of Type.
Description: 
Value: 47'''
        pass

    def kDoubleIndexedComponent(self):
        '''This is an enum of Type.
Description: 
Value: 698'''
        pass

    def kLimitManip(self):
        '''This is an enum of Type.
Description: 
Value: 135'''
        pass

    def kPlane(self):
        '''This is an enum of Type.
Description: 
Value: 287'''
        pass

    def kButtonManip(self):
        '''This is an enum of Type.
Description: 
Value: 153'''
        pass

    def kSubdMoveEdge(self):
        '''This is an enum of Type.
Description: 
Value: 836'''
        pass

    def kSnapshotShape(self):
        '''This is an enum of Type.
Description: 
Value: 839'''
        pass

    def kCollision(self):
        '''This is an enum of Type.
Description: 
Value: 252'''
        pass

    def kStroke(self):
        '''This is an enum of Type.
Description: 
Value: 748'''
        pass

    def kTransferAttributes(self):
        '''This is an enum of Type.
Description: 
Value: 966'''
        pass

    def kImageBlur(self):
        '''This is an enum of Type.
Description: 
Value: 651'''
        pass

    def kSkinShader(self):
        '''This is an enum of Type.
Description: 
Value: 658'''
        pass

    def kPositionMarker(self):
        '''This is an enum of Type.
Description: 
Value: 284'''
        pass

    def kReverseCurveManip(self):
        '''This is an enum of Type.
Description: 
Value: 181'''
        pass

    def kPASolver(self):
        '''This is an enum of Type.
Description: 
Value: 356'''
        pass

    def kBlendNodeFloat(self):
        '''This is an enum of Type.
Description: 
Value: 999'''
        pass

    def kMatrixHold(self):
        '''This is an enum of Type.
Description: 
Value: 384'''
        pass

    def kTextButtonManip(self):
        '''This is an enum of Type.
Description: 
Value: 637'''
        pass

    def kSubdTweak(self):
        '''This is an enum of Type.
Description: 
Value: 863'''
        pass

    def kDynFieldsManip(self):
        '''This is an enum of Type.
Description: 
Value: 706'''
        pass

    def kTranslateBoxManip(self):
        '''This is an enum of Type.
Description: 
Value: 225'''
        pass

    def kPolyTriangulate(self):
        '''This is an enum of Type.
Description: 
Value: 423'''
        pass

    def kGranite(self):
        '''This is an enum of Type.
Description: 
Value: 499'''
        pass

    def kRenderCone(self):
        '''This is an enum of Type.
Description: 
Value: 97'''
        pass

    def kObjectRenderFilter(self):
        '''This is an enum of Type.
Description: 
Value: 666'''
        pass

    def kPolyMergeVert(self):
        '''This is an enum of Type.
Description: 
Value: 682'''
        pass

    def kDeleteUVSet(self):
        '''This is an enum of Type.
Description: 
Value: 781'''
        pass

    def kRenderLayer(self):
        '''This is an enum of Type.
Description: 
Value: 769'''
        pass

    def kOrthoGrid(self):
        '''This is an enum of Type.
Description: 
Value: 290'''
        pass

    def kIkRPManip(self):
        '''This is an enum of Type.
Description: 
Value: 167'''
        pass

    def kProxyManager(self):
        '''This is an enum of Type.
Description: 
Value: 942'''
        pass

    def kFloatAngleAttribute(self):
        '''This is an enum of Type.
Description: 
Value: 556'''
        pass

    def kRevolvedPrimitive(self):
        '''This is an enum of Type.
Description: 
Value: 95'''
        pass

    def kCreateBPManip(self):
        '''This is an enum of Type.
Description: 
Value: 817'''
        pass

    def kQuadShadingSwitch(self):
        '''This is an enum of Type.
Description: 
Value: 904'''
        pass

    def kCurveParamComponent(self):
        '''This is an enum of Type.
Description: 
Value: 527'''
        pass

    def kSkinClusterFilter(self):
        '''This is an enum of Type.
Description: 
Value: 671'''
        pass

    def kKeyframeRegionManip(self):
        '''This is an enum of Type.
Description: 
Value: 976'''
        pass

    def kCharacter(self):
        '''This is an enum of Type.
Description: 
Value: 672'''
        pass

    def kDisplayLayerManager(self):
        '''This is an enum of Type.
Description: 
Value: 718'''
        pass

    def kNObjectData(self):
        '''This is an enum of Type.
Description: 
Value: 987'''
        pass

    def kTrsManip(self):
        '''This is an enum of Type.
Description: 
Value: 189'''
        pass

    def kPolyColorMod(self):
        '''This is an enum of Type.
Description: 
Value: 724'''
        pass

    def kTimeFunction(self):
        '''This is an enum of Type.
Description: 
Value: 920'''
        pass

    def kPolyPrimitive(self):
        '''This is an enum of Type.
Description: 
Value: 425'''
        pass

    def kVolumeShader(self):
        '''This is an enum of Type.
Description: 
Value: 522'''
        pass

    def kColorBackground(self):
        '''This is an enum of Type.
Description: 
Value: 24'''
        pass

    def kDependencyNode(self):
        '''This is an enum of Type.
Description: 
Value: 4'''
        pass

    def kCacheableNode(self):
        '''This is an enum of Type.
Description: 
Value: 970'''
        pass

    def kNurbsCurve(self):
        '''This is an enum of Type.
Description: 
Value: 266'''
        pass

    def kPolyToSubdiv(self):
        '''This is an enum of Type.
Description: 
Value: 670'''
        pass

    def kDecayRegionComponent(self):
        '''This is an enum of Type.
Description: 
Value: 537'''
        pass

    def kAnimCurveTimeToAngular(self):
        '''This is an enum of Type.
Description: 
Value: 8'''
        pass

    def kEdgeComponent(self):
        '''This is an enum of Type.
Description: 
Value: 533'''
        pass

    def kAir(self):
        '''This is an enum of Type.
Description: 
Value: 256'''
        pass

    def kPfxHair(self):
        '''This is an enum of Type.
Description: 
Value: 925'''
        pass

    def kCharacterMap(self):
        '''This is an enum of Type.
Description: 
Value: 784'''
        pass

    def kHikHandle(self):
        '''This is an enum of Type.
Description: 
Value: 941'''
        pass

    def kPolyMapSewMove(self):
        '''This is an enum of Type.
Description: 
Value: 833'''
        pass

    def kGlobalCacheControls(self):
        '''This is an enum of Type.
Description: 
Value: 842'''
        pass

    def kWeightGeometryFilt(self):
        '''This is an enum of Type.
Description: 
Value: 342'''
        pass

    def kTowPointManip(self):
        '''This is an enum of Type.
Description: 
Value: 139'''
        pass

    def kHairTubeShader(self):
        '''This is an enum of Type.
Description: 
Value: 926'''
        pass

    def kControl(self):
        '''This is an enum of Type.
Description: 
Value: 474'''
        pass

    def kTorus(self):
        '''This is an enum of Type.
Description: 
Value: 602'''
        pass

    def kTranslateManip2D(self):
        '''This is an enum of Type.
Description: 
Value: 206'''
        pass

    def kGenericAttribute(self):
        '''This is an enum of Type.
Description: 
Value: 564'''
        pass

    def kLambertMaterial(self):
        '''This is an enum of Type.
Description: 
Value: 378'''
        pass

    def kScaleLimitsManip(self):
        '''This is an enum of Type.
Description: 
Value: 218'''
        pass

    def kDeformSquash(self):
        '''This is an enum of Type.
Description: 
Value: 613'''
        pass

    def kImageMultiply(self):
        '''This is an enum of Type.
Description: 
Value: 647'''
        pass

    def kPolyAppend(self):
        '''This is an enum of Type.
Description: 
Value: 392'''
        pass

    def kRenderLayerManager(self):
        '''This is an enum of Type.
Description: 
Value: 770'''
        pass

    def kData3Double(self):
        '''This is an enum of Type.
Description: 
Value: 584'''
        pass

    def kVortex(self):
        '''This is an enum of Type.
Description: 
Value: 263'''
        pass

    def kNurbsCurveGeom(self):
        '''This is an enum of Type.
Description: 
Value: 267'''
        pass

    def kTimeAttribute(self):
        '''This is an enum of Type.
Description: 
Value: 559'''
        pass

    def kNurbsCurveData(self):
        '''This is an enum of Type.
Description: 
Value: 578'''
        pass

    def kMultiplyDivide(self):
        '''This is an enum of Type.
Description: 
Value: 436'''
        pass

    def kModel(self):
        '''This is an enum of Type.
Description: 
Value: 3'''
        pass

    def kAttachCurve(self):
        '''This is an enum of Type.
Description: 
Value: 43'''
        pass

    def kPluginManipContainer(self):
        '''This is an enum of Type.
Description: Custom manipulator containers derived from
Value: 680'''
        pass

    def kFluidTexture2D(self):
        '''This is an enum of Type.
Description: 
Value: 888'''
        pass

    def kBarnDoorManip(self):
        '''This is an enum of Type.
Description: 
Value: 150'''
        pass

    def kMeshEdgeComponent(self):
        '''This is an enum of Type.
Description: 
Value: 539'''
        pass

    def kPolyBlindData(self):
        '''This is an enum of Type.
Description: 
Value: 742'''
        pass

    def kLight(self):
        '''This is an enum of Type.
Description: 
Value: 301'''
        pass

    def kRoundRadiusCrvManip(self):
        '''This is an enum of Type.
Description: 
Value: 633'''
        pass

    def kDistance(self):
        '''This is an enum of Type.
Description: 
Value: 271'''
        pass

    def kModifyEdgeBaseManip(self):
        '''This is an enum of Type.
Description: 
Value: 818'''
        pass

    def kSubdProjectionManip(self):
        '''This is an enum of Type.
Description: 
Value: 864'''
        pass

    def kMessageAttribute(self):
        '''This is an enum of Type.
Description: 
Value: 568'''
        pass

    def kPsdFileTexture(self):
        '''This is an enum of Type.
Description: 
Value: 927'''
        pass

    def kStitchSrf(self):
        '''This is an enum of Type.
Description: 
Value: 101'''
        pass

    def kUint64SingleIndexedComponent(self):
        '''This is an enum of Type.
Description: 
Value: 1011'''
        pass

    def kHwShaderNode(self):
        '''This is an enum of Type.
Description: 
Value: 869'''
        pass

    def kTranslateUVManip2D(self):
        '''This is an enum of Type.
Description: 
Value: 690'''
        pass

    def kWriteToLabelBuffer(self):
        '''This is an enum of Type.
Description: 
Value: 1018'''
        pass

    def kTwoPointArcManip(self):
        '''This is an enum of Type.
Description: 
Value: 636'''
        pass

    def kSubdivMapComponent(self):
        '''This is an enum of Type.
Description: 
Value: 840'''
        pass

    def kMidModifierWithMatrix(self):
        '''This is an enum of Type.
Description: 
Value: 389'''
        pass

    def kTxSl(self):
        '''This is an enum of Type.
Description: 
Value: 506'''
        pass

    def kManipContainer(self):
        '''This is an enum of Type.
Description: 
Value: 148'''
        pass

    def kTangentConstraint(self):
        '''This is an enum of Type.
Description: 
Value: 244'''
        pass

    def kFlexor(self):
        '''This is an enum of Type.
Description: 
Value: 298'''
        pass

    def kRenderSetup(self):
        '''This is an enum of Type.
Description: 
Value: 510'''
        pass

    def kPropMoveTriadManip(self):
        '''This is an enum of Type.
Description: 
Value: 138'''
        pass

    def kDummyConnectable(self):
        '''This is an enum of Type.
Description: 
Value: 323'''
        pass

    def kDynSweptGeometryData(self):
        '''This is an enum of Type.
Description: 
Value: 727'''
        pass

    def kTrsInsertManip(self):
        '''This is an enum of Type.
Description: 
Value: 203'''
        pass

    def kImageView(self):
        '''This is an enum of Type.
Description: 
Value: 655'''
        pass

    def kTexSmoothManip(self):
        '''This is an enum of Type.
Description: 
Value: 201'''
        pass

    def kDagSelectionItem(self):
        '''This is an enum of Type.
Description: 
Value: 550'''
        pass

    def kRigidDeform(self):
        '''This is an enum of Type.
Description: 
Value: 339'''
        pass

    def kProjectTangentManip(self):
        '''This is an enum of Type.
Description: 
Value: 177'''
        pass

    def kExtendSurface(self):
        '''This is an enum of Type.
Description: 
Value: 66'''
        pass

    def kRevolve(self):
        '''This is an enum of Type.
Description: 
Value: 94'''
        pass

    def kScaleConstraint(self):
        '''This is an enum of Type.
Description: 
Value: 243'''
        pass

    def kUnderWorld(self):
        '''This is an enum of Type.
Description: 
Value: 109'''
        pass

    def kDeleteComponent(self):
        '''This is an enum of Type.
Description: 
Value: 317'''
        pass

    def kUnused3(self):
        '''This is an enum of Type.
Description: 
Value: 825'''
        pass

    def kBlendTwoAttr(self):
        '''This is an enum of Type.
Description: 
Value: 28'''
        pass

    def kSl60(self):
        '''This is an enum of Type.
Description: 
Value: 469'''
        pass

    def kAttribute2Float(self):
        '''This is an enum of Type.
Description: 
Value: 732'''
        pass

    def kAISEnvFacade(self):
        '''This is an enum of Type.
Description: 
Value: 953'''
        pass

    def kPolySplitRing(self):
        '''This is an enum of Type.
Description: 
Value: 946'''
        pass

    def kMatrixAttribute(self):
        '''This is an enum of Type.
Description: 
Value: 566'''
        pass

    def kMoveUVShellManip2D(self):
        '''This is an enum of Type.
Description: 
Value: 694'''
        pass

    def kPolyMesh(self):
        '''This is an enum of Type.
Description: 
Value: 429'''
        pass

    def kExtrudeManip(self):
        '''This is an enum of Type.
Description: 
Value: 165'''
        pass

    def kPolyBevel(self):
        '''This is an enum of Type.
Description: 
Value: 390'''
        pass

    def kBackground(self):
        '''This is an enum of Type.
Description: 
Value: 23'''
        pass

    def kAnimCurveTimeToTime(self):
        '''This is an enum of Type.
Description: 
Value: 10'''
        pass

    def kPlusMinusAverage(self):
        '''This is an enum of Type.
Description: 
Value: 449'''
        pass

    def kPolySplitVert(self):
        '''This is an enum of Type.
Description: 
Value: 791'''
        pass

    def kContainer(self):
        '''This is an enum of Type.
Description: 
Value: 985'''
        pass

    def kUnused2(self):
        '''This is an enum of Type.
Description: 
Value: 824'''
        pass

    def kTrimManip(self):
        '''This is an enum of Type.
Description: 
Value: 228'''
        pass

    def kIntArrayData(self):
        '''This is an enum of Type.
Description: 
Value: 573'''
        pass

    def kFluidData(self):
        '''This is an enum of Type.
Description: 
Value: 895'''
        pass

    def kSoftModManip(self):
        '''This is an enum of Type.
Description: 
Value: 623'''
        pass

    def kDeformTwist(self):
        '''This is an enum of Type.
Description: 
Value: 612'''
        pass

    def kSmoothCurve(self):
        '''This is an enum of Type.
Description: 
Value: 684'''
        pass

    def kSubdModifyEdge(self):
        '''This is an enum of Type.
Description: 
Value: 808'''
        pass

    def kSoftModFilter(self):
        '''This is an enum of Type.
Description: 
Value: 344'''
        pass

    def kPluginTransformNode(self):
        '''This is an enum of Type.
Description: Custom transform node derived from
Value: 892'''
        pass

    def kDynGlobals(self):
        '''This is an enum of Type.
Description: 
Value: 753'''
        pass

    def kCurveFromMeshCoM(self):
        '''This is an enum of Type.
Description: 
Value: 913'''
        pass

    def kChooser(self):
        '''This is an enum of Type.
Description: 
Value: 756'''
        pass

    def kGroupId(self):
        '''This is an enum of Type.
Description: 
Value: 347'''
        pass

    def kUnitToTimeConversion(self):
        '''This is an enum of Type.
Description: 
Value: 518'''
        pass

    def kBlendNodeInt16(self):
        '''This is an enum of Type.
Description: 
Value: 1002'''
        pass

    def kRemapHsv(self):
        '''This is an enum of Type.
Description: 
Value: 918'''
        pass

    def kBrush(self):
        '''This is an enum of Type.
Description: 
Value: 749'''
        pass

    def kIkHandle(self):
        '''This is an enum of Type.
Description: 
Value: 120'''
        pass

    def kInstancer(self):
        '''This is an enum of Type.
Description: 
Value: 746'''
        pass

    def kFloatArrayData(self):
        '''This is an enum of Type.
Description: 
Value: 1008'''
        pass

    def kRBFsurface(self):
        '''This is an enum of Type.
Description: 
Value: 89'''
        pass

    def kPluginIkSolver(self):
        '''This is an enum of Type.
Description: Custom IK Solvers derived from
Value: 745'''
        pass

    def kAddDoubleLinear(self):
        '''This is an enum of Type.
Description: 
Value: 5'''
        pass

    def kPolyMoveFacetUV(self):
        '''This is an enum of Type.
Description: 
Value: 409'''
        pass

    def kPolyModifierManip(self):
        '''This is an enum of Type.
Description: 
Value: 195'''
        pass

    def kNurbsBoolean(self):
        '''This is an enum of Type.
Description: 
Value: 677'''
        pass

    def kOceanShader(self):
        '''This is an enum of Type.
Description: 
Value: 878'''
        pass

    def kRoundConstantRadius(self):
        '''This is an enum of Type.
Description: 
Value: 631'''
        pass

    def kManipulator3D(self):
        '''This is an enum of Type.
Description: 
Value: 122'''
        pass

    def kSpotCylinderManip(self):
        '''This is an enum of Type.
Description: 
Value: 187'''
        pass

    def kData2Short(self):
        '''This is an enum of Type.
Description: 
Value: 583'''
        pass

    def kNonLinear(self):
        '''This is an enum of Type.
Description: 
Value: 609'''
        pass

    def kIkEffector(self):
        '''This is an enum of Type.
Description: 
Value: 119'''
        pass

    def kTriplanarProjectionManip(self):
        '''This is an enum of Type.
Description: 
Value: 188'''
        pass

    def kIllustratorCurve(self):
        '''This is an enum of Type.
Description: 
Value: 74'''
        pass

    def kCloth(self):
        '''This is an enum of Type.
Description: 
Value: 487'''
        pass

    def kEditCurveManip(self):
        '''This is an enum of Type.
Description: 
Value: 802'''
        pass

    def kFilter(self):
        '''This is an enum of Type.
Description: 
Value: 328'''
        pass

    def kPluginDependNode(self):
        '''This is an enum of Type.
Description: Custom dependency nodes derived from
Value: 447'''
        pass

    def kDoubleShadingSwitch(self):
        '''This is an enum of Type.
Description: 
Value: 605'''
        pass

    def kNucleus(self):
        '''This is an enum of Type.
Description: 
Value: 971'''
        pass

    def kDiskCache(self):
        '''This is an enum of Type.
Description: 
Value: 843'''
        pass

    def kAlignCurve(self):
        '''This is an enum of Type.
Description: 
Value: 41'''
        pass

    def kPolyCutManipContainer(self):
        '''This is an enum of Type.
Description: 
Value: 884'''
        pass

    def kMeshData(self):
        '''This is an enum of Type.
Description: 
Value: 576'''
        pass

    def kJointTranslateManip(self):
        '''This is an enum of Type.
Description: 
Value: 229'''
        pass

    def kDeformSquashManip(self):
        '''This is an enum of Type.
Description: 
Value: 619'''
        pass

    def kMatrixData(self):
        '''This is an enum of Type.
Description: 
Value: 575'''
        pass

    def kUVManip2D(self):
        '''This is an enum of Type.
Description: 
Value: 689'''
        pass

    def kLightManip(self):
        '''This is an enum of Type.
Description: 
Value: 169'''
        pass

    def kCoiManip(self):
        '''This is an enum of Type.
Description: 
Value: 155'''
        pass

    def kAngle(self):
        '''This is an enum of Type.
Description: 
Value: 269'''
        pass

    def kPointLight(self):
        '''This is an enum of Type.
Description: 
Value: 308'''
        pass

    def kPolyMoveVertex(self):
        '''This is an enum of Type.
Description: 
Value: 411'''
        pass

    def kCondition(self):
        '''This is an enum of Type.
Description: 
Value: 37'''
        pass

    def kCurveFromSurfaceCoS(self):
        '''This is an enum of Type.
Description: 
Value: 60'''
        pass

    def kBlendNodeAdditiveRotation(self):
        '''This is an enum of Type.
Description: 
Value: 1005'''
        pass

    def kDynArrayAttrsData(self):
        '''This is an enum of Type.
Description: 
Value: 713'''
        pass

    def kToggleManip(self):
        '''This is an enum of Type.
Description: 
Value: 224'''
        pass

    def kMultilisterLight(self):
        '''This is an enum of Type.
Description: 
Value: 435'''
        pass

    def kLightSourceMaterial(self):
        '''This is an enum of Type.
Description: 
Value: 381'''
        pass

    def kComponentListData(self):
        '''This is an enum of Type.
Description: 
Value: 571'''
        pass

    def kEnvBall(self):
        '''This is an enum of Type.
Description: 
Value: 479'''
        pass

    def kSphereData(self):
        '''This is an enum of Type.
Description: 
Value: 590'''
        pass

    def kHardwareRenderGlobals(self):
        '''This is an enum of Type.
Description: 
Value: 515'''
        pass

    def kPolyCone(self):
        '''This is an enum of Type.
Description: 
Value: 426'''
        pass

    def kCylinder(self):
        '''This is an enum of Type.
Description: 
Value: 98'''
        pass

    def kSubdivSurfaceVarGroup(self):
        '''This is an enum of Type.
Description: 
Value: 820'''
        pass

    def kMultDoubleLinear(self):
        '''This is an enum of Type.
Description: 
Value: 758'''
        pass

    def kManipulator(self):
        '''This is an enum of Type.
Description: 
Value: 230'''
        pass

    def kDefaultLightList(self):
        '''This is an enum of Type.
Description: 
Value: 316'''
        pass

    def kBoxData(self):
        '''This is an enum of Type.
Description: 
Value: 846'''
        pass

    def kSurfaceRangeComponent(self):
        '''This is an enum of Type.
Description: 
Value: 535'''
        pass

    def kSquareSrf(self):
        '''This is an enum of Type.
Description: 
Value: 701'''
        pass

    def kTexture2d(self):
        '''This is an enum of Type.
Description: 
Value: 484'''
        pass

    def kRoundRadiusManip(self):
        '''This is an enum of Type.
Description: 
Value: 632'''
        pass

    def kImagePlane(self):
        '''This is an enum of Type.
Description: 
Value: 361'''
        pass

    def kSPbirailSrf(self):
        '''This is an enum of Type.
Description: 
Value: 52'''
        pass

    def kTextureBakeSet(self):
        '''This is an enum of Type.
Description: 
Value: 460'''
        pass

    def kRgbToHsv(self):
        '''This is an enum of Type.
Description: 
Value: 457'''
        pass

    def kSelectionListOperator(self):
        '''This is an enum of Type.
Description: 
Value: 668'''
        pass

    def kRamp(self):
        '''This is an enum of Type.
Description: 
Value: 492'''
        pass

    def kShape(self):
        '''This is an enum of Type.
Description: 
Value: 247'''
        pass

    def kDynSpreadManip(self):
        '''This is an enum of Type.
Description: 
Value: 711'''
        pass

    def kClosestPointOnMesh(self):
        '''This is an enum of Type.
Description: 
Value: 965'''
        pass

    def kExtract(self):
        '''This is an enum of Type.
Description: 
Value: 327'''
        pass

    def kBlendNodeBase(self):
        '''This is an enum of Type.
Description: 
Value: 993'''
        pass

    def kCircleSweepManip(self):
        '''This is an enum of Type.
Description: 
Value: 128'''
        pass

    def kDeformTwistManip(self):
        '''This is an enum of Type.
Description: 
Value: 618'''
        pass

    def kLambert(self):
        '''This is an enum of Type.
Description: 
Value: 362'''
        pass

    def kPolyNormalPerVertex(self):
        '''This is an enum of Type.
Description: 
Value: 743'''
        pass

    def kScaleManip(self):
        '''This is an enum of Type.
Description: 
Value: 219'''
        pass

    def kReflect(self):
        '''This is an enum of Type.
Description: 
Value: 363'''
        pass

    def kDirectedDisc(self):
        '''This is an enum of Type.
Description: 
Value: 275'''
        pass

    def kHyperGraphInfo(self):
        '''This is an enum of Type.
Description: 
Value: 351'''
        pass

    def kDblTrsManip(self):
        '''This is an enum of Type.
Description: 
Value: 190'''
        pass

    def kAngleBetween(self):
        '''This is an enum of Type.
Description: 
Value: 21'''
        pass

    def kPolyFlipUV(self):
        '''This is an enum of Type.
Description: 
Value: 868'''
        pass

    def kSingleIndexedComponent(self):
        '''This is an enum of Type.
Description: 
Value: 697'''
        pass

    def kReverseCurve(self):
        '''This is an enum of Type.
Description: 
Value: 92'''
        pass

    def kOffsetCosManip(self):
        '''This is an enum of Type.
Description: 
Value: 171'''
        pass

    def kUnitAttribute(self):
        '''This is an enum of Type.
Description: 
Value: 561'''
        pass

    def kProxy(self):
        '''This is an enum of Type.
Description: 
Value: 108'''
        pass

    def kKeyframeDeltaMove(self):
        '''This is an enum of Type.
Description: 
Value: 929'''
        pass

    def kAttribute(self):
        '''This is an enum of Type.
Description: 
Value: 553'''
        pass

    def kCurveCurveIntersect(self):
        '''This is an enum of Type.
Description: 
Value: 627'''
        pass

    def kPolyMapDel(self):
        '''This is an enum of Type.
Description: 
Value: 403'''
        pass

    def kPolyExtrudeVertex(self):
        '''This is an enum of Type.
Description: 
Value: 905'''
        pass

    def kHairSystem(self):
        '''This is an enum of Type.
Description: 
Value: 915'''
        pass

    def kBox(self):
        '''This is an enum of Type.
Description: 
Value: 847'''
        pass

    def kVolumeLight(self):
        '''This is an enum of Type.
Description: 
Value: 877'''
        pass

    def kVertexBakeSet(self):
        '''This is an enum of Type.
Description: 
Value: 461'''
        pass

    def kFloatMatrixAttribute(self):
        '''This is an enum of Type.
Description: 
Value: 567'''
        pass

    def kDeleteColorSet(self):
        '''This is an enum of Type.
Description: 
Value: 721'''
        pass

    def kXformManip(self):
        '''This is an enum of Type.
Description: 
Value: 909'''
        pass

    def kUnused6(self):
        '''This is an enum of Type.
Description: 
Value: 828'''
        pass

    def kUnused5(self):
        '''This is an enum of Type.
Description: 
Value: 827'''
        pass

    def kUnused4(self):
        '''This is an enum of Type.
Description: 
Value: 826'''
        pass

    def kJointCluster(self):
        '''This is an enum of Type.
Description: 
Value: 345'''
        pass

    def kCircleManip(self):
        '''This is an enum of Type.
Description: 
Value: 126'''
        pass

    def kUnused1(self):
        '''This is an enum of Type.
Description: 
Value: 823'''
        pass

    def kWire(self):
        '''This is an enum of Type.
Description: 
Value: 346'''
        pass

    def kRenderUtilityList(self):
        '''This is an enum of Type.
Description: 
Value: 455'''
        pass

    def kWorld(self):
        '''This is an enum of Type.
Description: 
Value: 246'''
        pass

    def kAttribute3Short(self):
        '''This is an enum of Type.
Description: 
Value: 737'''
        pass

    def kGroundPlane(self):
        '''This is an enum of Type.
Description: 
Value: 289'''
        pass

    def kCopyColorSet(self):
        '''This is an enum of Type.
Description: 
Value: 722'''
        pass

    def kAimConstraint(self):
        '''This is an enum of Type.
Description: 
Value: 111'''
        pass

    def kSubdMapCut(self):
        '''This is an enum of Type.
Description: 
Value: 852'''
        pass

    def kFFfilletSrf(self):
        '''This is an enum of Type.
Description: 
Value: 69'''
        pass

    def kSpotManip(self):
        '''This is an enum of Type.
Description: 
Value: 186'''
        pass

    def kFilterClosestSample(self):
        '''This is an enum of Type.
Description: 
Value: 329'''
        pass

    def kTexSmudgeUVManip(self):
        '''This is an enum of Type.
Description: 
Value: 198'''
        pass

    def kParticleTransparencyMapper(self):
        '''This is an enum of Type.
Description: 
Value: 443'''
        pass

    def kNonAmbientLight(self):
        '''This is an enum of Type.
Description: 
Value: 303'''
        pass

    def kPivotComponent(self):
        '''This is an enum of Type.
Description: 
Value: 529'''
        pass

    def kObjectScriptFilter(self):
        '''This is an enum of Type.
Description: 
Value: 667'''
        pass

    def kSubdBlindData(self):
        '''This is an enum of Type.
Description: 
Value: 783'''
        pass

    def kCurveKnotComponent(self):
        '''This is an enum of Type.
Description: 
Value: 526'''
        pass

    def kShadingMap(self):
        '''This is an enum of Type.
Description: 
Value: 465'''
        pass

    def kPluginConstraintNode(self):
        '''This is an enum of Type.
Description: Custom constraint node derived from
Value: 989'''
        pass

    def kMatrixPass(self):
        '''This is an enum of Type.
Description: 
Value: 386'''
        pass

    def kBlindData(self):
        '''This is an enum of Type.
Description: 
Value: 740'''
        pass

    def kCurveEdManip(self):
        '''This is an enum of Type.
Description: 
Value: 159'''
        pass

    def kRotateManip(self):
        '''This is an enum of Type.
Description: 
Value: 215'''
        pass

    def kChoice(self):
        '''This is an enum of Type.
Description: 
Value: 36'''
        pass

    def kClipLibrary(self):
        '''This is an enum of Type.
Description: 
Value: 764'''
        pass

    def kRotateLimitsManip(self):
        '''This is an enum of Type.
Description: 
Value: 217'''
        pass

    def kPhongExplorer(self):
        '''This is an enum of Type.
Description: 
Value: 366'''
        pass

    def kLineManip(self):
        '''This is an enum of Type.
Description: 
Value: 147'''
        pass

    def kHairConstraint(self):
        '''This is an enum of Type.
Description: 
Value: 919'''
        pass

    def kMute(self):
        '''This is an enum of Type.
Description: 
Value: 910'''
        pass

    def kRampShader(self):
        '''This is an enum of Type.
Description: 
Value: 876'''
        pass

    def kLinearLight(self):
        '''This is an enum of Type.
Description: 
Value: 305'''
        pass

    def kData4Double(self):
        '''This is an enum of Type.
Description: 
Value: 861'''
        pass

    def kImageDepth(self):
        '''This is an enum of Type.
Description: 
Value: 653'''
        pass

    def kTexLattice(self):
        '''This is an enum of Type.
Description: 
Value: 200'''
        pass

    def kRenderPass(self):
        '''This is an enum of Type.
Description: 
Value: 767'''
        pass

    def kPolyMappingManip(self):
        '''This is an enum of Type.
Description: 
Value: 194'''
        pass

    def kSubdSplitFace(self):
        '''This is an enum of Type.
Description: 
Value: 849'''
        pass

    def kSubdMoveVertex(self):
        '''This is an enum of Type.
Description: 
Value: 835'''
        pass

    def kSolidFractal(self):
        '''This is an enum of Type.
Description: 
Value: 504'''
        pass

    def kJoint(self):
        '''This is an enum of Type.
Description: 
Value: 121'''
        pass

    def kPassContributionMap(self):
        '''This is an enum of Type.
Description: 
Value: 771'''
        pass

    def kEmitter(self):
        '''This is an enum of Type.
Description: 
Value: 254'''
        pass

    def kAttribute2Int(self):
        '''This is an enum of Type.
Description: 
Value: 734'''
        pass

    def kPolyDelVertex(self):
        '''This is an enum of Type.
Description: 
Value: 400'''
        pass

    def kUnknownDag(self):
        '''This is an enum of Type.
Description: 
Value: 315'''
        pass

    def kSubdBoolean(self):
        '''This is an enum of Type.
Description: 
Value: 807'''
        pass

    def kGroupParts(self):
        '''This is an enum of Type.
Description: 
Value: 348'''
        pass

    def kData2Int(self):
        '''This is an enum of Type.
Description: 
Value: 582'''
        pass

    def kBlendManip(self):
        '''This is an enum of Type.
Description: 
Value: 152'''
        pass

    def kVolumeFog(self):
        '''This is an enum of Type.
Description: 
Value: 850'''
        pass

    def kSummaryObject(self):
        '''This is an enum of Type.
Description: 
Value: 472'''
        pass

    def kDoubleArrayData(self):
        '''This is an enum of Type.
Description: 
Value: 572'''
        pass

    def kAttribute3Long(self):
        '''This is an enum of Type.
Description: Used for backward compatibility.
Value: 738'''
        pass

    def kCloseSurface(self):
        '''This is an enum of Type.
Description: 
Value: 57'''
        pass

    def kCurveSegmentManip(self):
        '''This is an enum of Type.
Description: 
Value: 160'''
        pass

    def kStateManip(self):
        '''This is an enum of Type.
Description: 
Value: 145'''
        pass

    def kHikSolver(self):
        '''This is an enum of Type.
Description: 
Value: 940'''
        pass

    def kToggleOnLineManip(self):
        '''This is an enum of Type.
Description: 
Value: 144'''
        pass

    def kArrowManip(self):
        '''This is an enum of Type.
Description: 
Value: 123'''
        pass

    def kSmoothTangentSrf(self):
        '''This is an enum of Type.
Description: 
Value: 766'''
        pass

    def kParticleIncandecenceMapper(self):
        '''This is an enum of Type.
Description: 
Value: 442'''
        pass

    def kCommCornerOperManip(self):
        '''This is an enum of Type.
Description: 
Value: 600'''
        pass

    def kPolyMirror(self):
        '''This is an enum of Type.
Description: 
Value: 937'''
        pass

    def kScript(self):
        '''This is an enum of Type.
Description: 
Value: 625'''
        pass

    def kFitBspline(self):
        '''This is an enum of Type.
Description: 
Value: 71'''
        pass

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

class MFnAmbientLight:
    '''Manage Ambient Light dependency Nodes. MFnAmbientLight facilitates creation and manipulation of ambient light dependency graph nodes. '''
    def __init__(self):
        pass


    def setCastSoftShadows(self, cast_soft_shadows): 
        '''setCastSoftShadows(self, cast_soft_shadows)
Arguments:
	[in]	cast_soft_shadows = bool


Sets the value of the "castSoftShadows" attribute of an ambient light node.'''
        pass

    def create(self, parent, UIvisible, wantTransform): 
        '''create(self, parent, UIvisible, wantTransform) -> MObject
Returns: MObject representing the new dependency node.

Arguments:
	[in]	parent = MObject
	[in]	UIvisible = bool
	[in]	wantTransform = bool


Creates a new ambient light dependency graph node and adds it to the dependency graph. If the UIvisible parameter is true, the new node will be connected to the light classification node (which allows the UI to recognize the node as a light) and added to the default light list. If UIvisible is false, the node will be created in isolation.'''
        pass

    def setAmbientShade(self, ambient_shade): 
        '''setAmbientShade(self, ambient_shade)
Arguments:
	[in]	ambient_shade = float


Sets the value of the "ambientShade" attribute of an ambient light node.'''
        pass

    def ambientShade(self): 
        '''ambientShade(self) -> float
Returns: The value of the "ambientShade" attribute of the ambient light node.


Retrieves the value of the "ambientShade" attribute of an ambient light node. This attribute determines how positional the light is. A value of 0 represents a completely ambient light, while a value of 1 represents a point light.'''
        pass

    def className(self): 
        '''className(self) -> char*

'''
        pass

    def setShadowRadius(self, shadow_radius): 
        '''setShadowRadius(self, shadow_radius)
Arguments:
	[in]	shadow_radius = float


Sets the value of the "shadowRadius" attribute of an ambient light node.'''
        pass

    def shadowRadius(self): 
        '''shadowRadius(self) -> float
Returns: The value of the "shadowRadius" attribute of the ambient light node.


Retrieves the value of the "shadowRadius" attribute of an ambient light node. This attribute represents the radius of the light used when computing soft shadows. Higher radius values result in more extended soft shadows.'''
        pass

    def type(self): 
        '''type(self) -> MFn.Type

'''
        pass

    def castSoftShadows(self): 
        '''castSoftShadows(self) -> bool
Returns: The value of the "castSoftShadows" attribute of the ambient light node.


Retrieves the value of the "castSoftShadows" attribute of an ambient light node. This attribute determines whether or not the light casts soft shadows.'''
        pass

class MFnAnisotropyShader:
    '''Manage anisotropic shaders. MFnAnisotropyShader facilitates creation and manipulation of dependency graph nodes representing anisotropy shaders. '''
    def __init__(self):
        pass


    def setTangentUCamera(self, tangu_camera): 
        '''setTangentUCamera(self, tangu_camera)
Arguments:
	[in]	tangu_camera = MColor


Sets the value of the "color" attribute of a shader node.'''
        pass

    def correlationX(self): 
        '''correlationX(self) -> float
Returns: The value of the "spreadX" attribute of the shader node.


Retrieves the value of the "spreadX" attribute of a shader node.'''
        pass

    def setCorrelationY(self, correl_y): 
        '''setCorrelationY(self, correl_y)
Arguments:
	[in]	correl_y = float


Sets the value of the "spreadY" attribute of a shader node.'''
        pass

    def setTangentVCamera(self, tangv_camera): 
        '''setTangentVCamera(self, tangv_camera)
Arguments:
	[in]	tangv_camera = MColor


Sets the value of the "transparency" attribute of a shader node.'''
        pass

    def refractiveIndex(self): 
        '''refractiveIndex(self) -> float
Returns: The value of the "fresnelRefractiveIndex" attribute of the shader node.


Retrieves the value of the "fresnelRefractiveIndex" attribute of a layered shader node.'''
        pass

    def correlationY(self): 
        '''correlationY(self) -> float
Returns: The value of the "spreadY" attribute of the shader node.


Retrieves the value of the "spreadY" attribute of a shader node.'''
        pass

    def tangentVCamera(self): 
        '''tangentVCamera(self) -> MColor
Returns: The value of the "transparency" attribute of the shader node.


Retrieves the value of the "transparency" attribute of a shader node. This attribute represents the surface transparency of the shader.'''
        pass

    def create(self, UIvisible): 
        '''create(self, UIvisible) -> MObject
Returns: MObject representing the new dependency node.

Arguments:
	[in]	UIvisible = bool


Creates a new layered shader dependency graph node and adds it to the dependency graph. If the UIvisible parameter is true, the new node will be connected to the shader classification node (which allows the UI to recognize the node as a shader). If UIvisible is false, the node will be created in isolation.'''
        pass

    def setRotateAngle(self, rotate_angle): 
        '''setRotateAngle(self, rotate_angle)
Arguments:
	[in]	rotate_angle = float


Sets the value of the "angle" attribute of a shader node.'''
        pass

    def setRefractiveIndex(self, refractive_index): 
        '''setRefractiveIndex(self, refractive_index)
Arguments:
	[in]	refractive_index = float


Sets the value of the "fresnelRefractiveIndex" attribute of a shader node.'''
        pass

    def roughness(self): 
        '''roughness(self) -> float
Returns: The value of the "roughness" attribute of the shader node.


Retrieves the value of the "roughness" attribute of a shader node.'''
        pass

    def className(self): 
        '''className(self) -> char*

'''
        pass

    def anisotropicReflectivity(self): 
        '''anisotropicReflectivity(self) -> bool
Returns: The value of the "anisotropicReflectivity" attribute of the shader node.


Retrieves the value of the "anisotropicReflectivity" attribute of a layered shader node.'''
        pass

    def setCorrelationX(self, correl_x): 
        '''setCorrelationX(self, correl_x)
Arguments:
	[in]	correl_x = float


Sets the value of the "spreadX" attribute of a shader node.'''
        pass

    def rotateAngle(self): 
        '''rotateAngle(self) -> float
Returns: The value of the "angle" attribute of the shader node.


Retrieves the value of the "angle" attribute of a layered shader node.'''
        pass

    def setAnisotropicReflectivity(self, anisotropic_reflectivity): 
        '''setAnisotropicReflectivity(self, anisotropic_reflectivity)
Arguments:
	[in]	anisotropic_reflectivity = bool


Sets the value of the "anisotropicReflectivity" attribute of a shader node.'''
        pass

    def type(self): 
        '''type(self) -> MFn.Type

'''
        pass

    def setRoughness(self, roughness): 
        '''setRoughness(self, roughness)
Arguments:
	[in]	roughness = float


Sets the value of the "roughness" attribute of a shader node.'''
        pass

    def tangentUCamera(self): 
        '''tangentUCamera(self) -> MColor
Returns: The value of the "color" attribute of the shader node.


Retrieves the value of the "color" attribute of a shader node. This attribute represents the surface color of the shader.'''
        pass

class MFnAreaLight:
    '''Manage Area Light dependency Nodes. MFnAreaLight facilitates creation and manipulation of dependency graph nodes representing area lights. '''
    def __init__(self):
        pass


    def className(self): 
        '''className(self) -> char*

'''
        pass

    def create(self, parent, UIvisible, wantTransform): 
        '''create(self, parent, UIvisible, wantTransform) -> MObject
Returns: MObject representing the new dependency node.

Arguments:
	[in]	parent = MObject
	[in]	UIvisible = bool
	[in]	wantTransform = bool


Creates a new area light dependency graph node and adds it to the dependency graph. If the UIvisible parameter is true, the new node will be connected to the light classification node (which allows the UI to recognize the node as a light) and added to the default light list. If UIvisible is false, the node will be created in isolation.'''
        pass

    def type(self): 
        '''type(self) -> MFn.Type

'''
        pass

class MFnArrayAttrsData:
    '''Function set for multiple arrays of attributes for dependency node data. MFnArrayAttrsData allows the creation and manipulation of multiple arrays of attributes as a data object over a single connection for use as dependency graph data.If a user written dependency node either accepts or produces MFnArrayAttrsData, then this class is used to extract or create the data that comes from or goes to other dependency graph nodes. The MDataHandle::type method will return kDynArrayAttrsData when data of this type is present. To access it, the MDataHandle::data() method is used to get an MObject for the data and this should then be used to initialize an instance of MFnArrayAttrsData.NOTE: these data attributes are not storable. '''
    def __init__(self):
        pass


    def count(self): 
        '''count(self) -> int


Returns the number of attribute arrays.'''
        pass

    def doubleArray(self, name): 
        '''doubleArray(self, name) -> MDoubleArray
Returns: A copy of the MDoubleArray held in this instance 

Arguments:
	[in]	name = MString


Return an  MDoubleArray  containing the double array currently operated upon by the function set. The  MDoubleArray  returned by this method is editable, so any changes to the return instance also affects the  MObject  operated upon by this function set. If the array did not exist it will be created.'''
        pass

    def getIntData(self, attrName): 
        '''getIntData(self, attrName) -> MIntArray
Returns: A copy of the MIntArray held in this instance 

Arguments:
	[in]	attrName = MString


Return an  MIntArray  containing the int array currently operated upon by the function set. The  MIntArray  returned by this method is read only. If the array did not exist it will be created.'''
        pass

    def getDoubleData(self, attrName): 
        '''getDoubleData(self, attrName) -> MDoubleArray
Returns: A copy of the MDoubleArray held in this instance 

Arguments:
	[in]	attrName = MString


Return an  MDoubleArray  containing the double array currently operated upon by the function set. The  MDoubleArray  returned by this method is read only. If the array did not exist it will be created.'''
        pass

    def getVectorData(self, attrName): 
        '''getVectorData(self, attrName) -> MVectorArray
Returns: A copy of the MVectorArray held in this instance 

Arguments:
	[in]	attrName = MString


Return an  MVectorArray  containing the vector array currently operated upon by the function set. The  MVectorArray  returned by this method is read only. If the array did not exist it will be created.'''
        pass

    def kInvalid(self):
        '''This is an enum of Type.
Description: Invalid value.
Value: 0'''
        pass

    def kIntArray(self):
        '''This is an enum of Type.
Description: 
Value: 3'''
        pass

    def kDoubleArray(self):
        '''This is an enum of Type.
Description: 
Value: 2'''
        pass

    def kVectorArray(self):
        '''This is an enum of Type.
Description: 
Value: 1'''
        pass

    def kLast(self):
        '''This is an enum of Type.
Description: Last value. It does not represent real data, but can be used to loop on all possible types
Value: 5'''
        pass

    def kStringArray(self):
        '''This is an enum of Type.
Description: 
Value: 4'''
        pass

    class Type:
        '''Non-functional class.  Values for this enum:
        kInvalid
        kIntArray
        kDoubleArray
        kVectorArray
        kLast
        kStringArray
'''
        def __init__(self):
            pass

    def clear(self): 
        '''clear(self)

Clear the contents of all of the arrays.'''
        pass

    def checkArrayExist(self, name, arrayType): 
        '''checkArrayExist(self, name, arrayType) -> bool
Returns: True if the array exists and false otherwise. 

Arguments:
	[in]	name = MString
	[in]	arrayType = MFnArrayAttrsData.Type


Check if the attribute array related to the given name has been created. If the named array exists return true and the array data type.'''
        pass

    def list(self): 
        '''list(self) -> MStringArray
Returns: A list of all the names of all the arrays stored in the data. 


Returns a list of names for the attribute arrays.'''
        pass

    def getStringData(self, attrName): 
        '''getStringData(self, attrName) -> MStringArray
Returns: A copy of the MStringArray held in this instance 

Arguments:
	[in]	attrName = MString


Return an  MStringArray  containing the string array currently operated upon by the function set. The  MStringArray  returned by this method is read only. If the array did not exist it will be created.'''
        pass

    def vectorArray(self, name): 
        '''vectorArray(self, name) -> MVectorArray
Returns: A copy of the MVectorArray held in this instance 

Arguments:
	[in]	name = MString


Return an  MVectorArray  containing the vector array currently operated upon by the function set. The  MVectorArray  returned by this method is editable, so any changes to the return instance also affects the  MObject  operated upon by this function set. If the array did not exist it will be created.'''
        pass

    def className(self): 
        '''className(self) -> char*

'''
        pass

    def intArray(self, name): 
        '''intArray(self, name) -> MIntArray
Returns: A copy of the MIntArray held in this instance 

Arguments:
	[in]	name = MString


Return an  MIntArray  containing the int array currently operated upon by the function set. The  MIntArray  returned by this method is editable, so any changes to the return instance also affects the  MObject  operated upon by this function set. If the array did not exist it will be created.'''
        pass

    def create(self): 
        '''create(self) -> MObject
Returns: The newly created MObject 


Create a new  MObject , attach it to this instance, and initialize it to be empty.'''
        pass

    def type(self): 
        '''type(self) -> MFn.Type

'''
        pass

    def stringArray(self, name): 
        '''stringArray(self, name) -> MStringArray
Returns: A copy of the MStringArray held in this instance 

Arguments:
	[in]	name = MString


Return an  MStringArray  containing the string array currently operated upon by the function set. The  MStringArray  returned by this method is editable, so any changes to the return instance also affects the  MObject  operated upon by this function set. If the array did not exist it will be created.'''
        pass

class MFnAttribute:
    '''Dependency node attribute function set. MFnAttribute is the function set for dependency node attributes.An attribute of a dependency node describes a piece of data that belongs to nodes of that type. For example, a node that makes a sphere might have a radius attribute. A node's attributes describe connections sites on the node that can be used in the dependency graph.Attributes typically belong to a class of nodes, rather than to an individual node. For example, all sphere nodes have a radius. Even though a single attribute may be shared by all nodes of a given type, each node will have its own value for the attribute.Attributes are heirarchical. For example, the translate scale attribute of a transform has x, y, and z child attributes.By default, attributes are:'''
    def __init__(self):
        pass


    def setConnectable(self, state): 
        '''setConnectable(self, state)
Arguments:
	[in]	state = bool


Sets whether this attribute should allow dependency graph connections. This should only get called in the initialize call of your node creator.'''
        pass

    def isUsedAsColor(self): 
        '''isUsedAsColor(self) -> bool
Returns: A boolean value indicating whether this attribute is used as a color


Returns true if this attribute is to be presented as a color in the UI.'''
        pass

    def isCached(self): 
        '''isCached(self) -> bool
Returns: A boolean value indicating whether this attribute is cached locally


Returns true if this attribute is cached locally in the node's data block. The default for this is true. Caching a node locally causes a copy of the attribute value for the node to be cached with the node. This removes the need to traverse through the graph to get the value each time it is requested.'''
        pass

    def setReadable(self, state): 
        '''setReadable(self, state)
Arguments:
	[in]	state = bool


Sets whether this attribute should be readable. If an attribute is readable, then it can be used as the source in a dependency graph connection.'''
        pass

    def setInternal(self, state): 
        '''setInternal(self, state)
Arguments:
	[in]	state = bool


The function controls an attribute's data storage. When set to true, the virtual methods  MPxNode::setInternalValueInContext()  and  MPxNode::getInternalValueInContext()  are invoked whenever the attribute value is set or queried, respectively. By default, attributes are not internal.'''
        pass

    def isRenderSource(self): 
        '''isRenderSource(self) -> bool
Returns: A boolean value indicating whether this attribute is render source


Returns true if this attribute is a render source. This attribute is used on rendering nodes to override the rendering sampler info.'''
        pass

    def setWorldSpace(self, state): 
        '''setWorldSpace(self, state)
Arguments:
	[in]	state = bool


Sets whether this attribute should be treated as worldspace. Being worldspace indicates the attribute is dependent on the worldSpace transformation of this node, and will be marked dirty by any attribute changes in the hierarchy that affects the worldSpace transformation. The attribute needs to be an array since during instancing there are multiple worldSpace paths to the node & Maya requires one array element per path for worldSpace attributes.'''
        pass

    def isStorable(self): 
        '''isStorable(self) -> bool
Returns: A boolean value indicating whether this attribute is storable


Returns true if this attribute is to be stored when the node is saved to a file.'''
        pass

    def setHidden(self, state): 
        '''setHidden(self, state)
Arguments:
	[in]	state = bool


Sets whether this attribute should be hidden from the UI. This is useful if the attribute is being used for blind data, or if it is being used as scratch space for a geometry calculation (should also be marked non-connectable in that case).'''
        pass

    def type(self): 
        '''type(self) -> MFn.Type

'''
        pass

    def isIndeterminant(self): 
        '''isIndeterminant(self) -> bool
Returns: A boolean value indicating whether this attribute is indeterminant


Returns true if this attribute is indeterminant. If an attribute may or may not be used during an evaluation then it is indeterminant. This attribute classification is mainly used on rendering nodes to indicate that some attributes are not always used.'''
        pass

    def parent(self): 
        '''parent(self) -> MObject
Returns: The parent attribute


Get the parent of this attribute, if it has one.'''
        pass

    def setChannelBox(self, state): 
        '''setChannelBox(self, state)
Arguments:
	[in]	state = bool


Sets whether this attribute should appear in the channel box when the node is selected. This should only get called in the initialize call of your node creator. Keyable attributes are always shown in the channel box so this flag is ignored on keyable attributes. It is for intended for use on non-keyable attributes which you want to appear in the channel box.'''
        pass

    def isWritable(self): 
        '''isWritable(self) -> bool
Returns: A boolean value indicating whether this attribute is writable


Returns true if this attribute is writable. If an attribute is writable, then it can be used as the destination in a dependency graph connection.'''
        pass

    def isConnectable(self): 
        '''isConnectable(self) -> bool
Returns: A boolean value indicating whether this attribute is connectable


Returns true if this attribute accepts dependency graph connections. If it does, then the readable and writable methods will indicate what types of connections are accepted.'''
        pass

    def name(self): 
        '''name(self) -> MString
Returns: The name of the attribute.


Returns the long name of the attribute. If the attribute has no long name then its short name is returned.'''
        pass

    def internal(self): 
        '''internal(self) -> bool
Returns: A boolean value indicating whether this attribute uses internal data


Returns true if a node has internal member data representing this attribute.'''
        pass

    def isKeyable(self): 
        '''isKeyable(self) -> bool
Returns: A boolean value indicating whether this attribute is keyable


Returns true if this attribute is keyable. Keyable attributes will be keyed by AutoKey and the Set Keyframe UI. Non-keyable attributes prevent the user from setting keys via the obvious UI provided for keying. Being non-keyable is not a hard block against adding keys to an attribute.'''
        pass

    def isAffectsWorldSpace(self): 
        '''isAffectsWorldSpace(self) -> bool
Returns: A boolean value indicating whether this attribute affects worldspace


Returns true if this attribute affects worldspace.'''
        pass

    def isHidden(self): 
        '''isHidden(self) -> bool
Returns: A boolean value indicating whether this attribute is hidden


Returns true if this attribute is to hidden from the UI. The attribute will not show up in attribute editors.'''
        pass

    def isArray(self): 
        '''isArray(self) -> bool
Returns: A boolean value indicating whether this attribute stores an array of data


Returns true if this attribute supports an array of data.'''
        pass

    def setKeyable(self, state): 
        '''setKeyable(self, state)
Arguments:
	[in]	state = bool


Sets whether this attribute should accept keyframe data. This should only get called in the initialize call of your node creator. Keyable attributes will be keyed by AutoKey and the Set Keyframe UI. Non-keyable attributes prevent the user from setting keys via the obvious UI provided for keying. Being non-keyable is not a hard block against adding keys to an attribute.'''
        pass

    def setAffectsWorldSpace(self, state): 
        '''setAffectsWorldSpace(self, state)
Arguments:
	[in]	state = bool


Sets whether this attribute should affect worldspace. NOTES: This property is ignored on non-dag nodes.'''
        pass

    def disconnectBehavior(self): 
        '''disconnectBehavior(self) -> MFnAttribute.DisconnectBehavior
Returns: The disconnect behavior


Returns the behavior of this attribute when it is disconnected. The possible settings are as follows:'''
        pass

    def setCached(self, state): 
        '''setCached(self, state)
Arguments:
	[in]	state = bool


Sets whether the data for this attribute is cached locally in the node's data block. The default for this is true. Caching a node locally causes a copy of the attribute value for the node to be cached with the node. This removes the need to traverse through the graph to get the value each time it is requested. This should only get called in the initialize call of your node creator.'''
        pass

    def setRenderSource(self, state): 
        '''setRenderSource(self, state)
Arguments:
	[in]	state = bool


Sets whether this attribute should be used as a render source attribute. When writing shader plug-ins, it is sometimes useful to be able to modify the sampler info, so upstream shading network can be re- evaluated with different sampler info values.'''
        pass

    def getAddAttrCmd(self, useLongName): 
        '''getAddAttrCmd(self, useLongName) -> MString
Returns: Return status

Arguments:
	[in]	useLongName = bool


Returns a string containing the  addAttr  command which would be required to recreate the  attribute  on a node. The command includes the terminating semicolon and is formatted as if for use with a selected node, meaning that it contains no node name.'''
        pass

    def indexMatters(self): 
        '''indexMatters(self) -> bool
Returns: true The user must specify the index when connecting to this attribute using connectAttr 
false The next available index can be used when connecting to this attribute using connectAttr -na


Determines whether the user must specify an index when connecting to this attribute, or whether the next available index can be used. This method only applies to array attributes which are non readable, i.e. destination attributes.'''
        pass

    def isChannelBoxFlagSet(self): 
        '''isChannelBoxFlagSet(self) -> bool
Returns: A boolean value indicating the status of the channel box flag on this attribute


Returns true if this attribute has its channel box flag set. Attributes will appear in the channel box if their channel box flag is set or if they are keyable.'''
        pass

    def setParent(self, parent): 
        '''setParent(self, parent)
Arguments:
	[in]	parent = MObject


Sets the parent attribute for this attribute. If the attribute was already a member of a compound, it will be removed from that attribute structure, and added to the specified one.'''
        pass

    def shortName(self): 
        '''shortName(self) -> MString
Returns: The name of the attribute.


Returns the short name of the attribute. If the attribute has no short name then its long name is returned.'''
        pass

    def setStorable(self, state): 
        '''setStorable(self, state)
Arguments:
	[in]	state = bool


Sets whether this attribute should be storable. If an attribute is storable, then it will be writen out when the node is stored to a file. This should only get called in the initialize call of your node creator.'''
        pass

    def setUsesArrayDataBuilder(self, state): 
        '''setUsesArrayDataBuilder(self, state)
Arguments:
	[in]	state = bool


Sets whether this attribute uses an array data builder. If true, then the  MArrayDataBuilder  class may be used with this attribute to generate its data. If false,  MArrayDataHandle::builder  will fail.'''
        pass

    def setDisconnectBehavior(self, behavior): 
        '''setDisconnectBehavior(self, behavior)
Arguments:
	[in]	behavior = MFnAttribute.DisconnectBehavior


Sets the disconnection behavior for this attribute. This determines what happens when a connection to this attribute is deleted. This should only get called in the initialize call of your node creator.'''
        pass

    def setIndeterminant(self, state): 
        '''setIndeterminant(self, state)
Arguments:
	[in]	state = bool


Sets whether this attribute is indeterminant. If an attribute may or may not be used during an evaluation then it is indeterminant. This attribute classification is mainly used on rendering nodes to indicate that some attributes are not always used.'''
        pass

    def kNothing(self):
        '''This is an enum of DisconnectBehavior.
Description: Do nothing to the attribute's value.
Value: 2'''
        pass

    def kReset(self):
        '''This is an enum of DisconnectBehavior.
Description: Reset the attribute to its default.
Value: 1'''
        pass

    def kDelete(self):
        '''This is an enum of DisconnectBehavior.
Description: Delete array element (array attributes only).
Value: 0'''
        pass

    class DisconnectBehavior:
        '''Non-functional class.  Values for this enum:
        kNothing
        kReset
        kDelete
'''
        def __init__(self):
            pass

    def usesArrayDataBuilder(self): 
        '''usesArrayDataBuilder(self) -> bool
Returns: A boolean value indicating whether this attribute uses an array data builder.


Returns true if this attribute uses an array data builder. If so, then the  MArrayDataBuilder  class may be used with this attribute.'''
        pass

    def isWorldSpace(self): 
        '''isWorldSpace(self) -> bool
Returns: A boolean value indicating whether this attribute is worldspace


Returns true if this attribute is worldspace.'''
        pass

    def accepts(self, id): 
        '''accepts(self, id) -> bool
Returns: A boolean value indicating whether a connection of that type is valid

Arguments:
	[in]	id = MTypeId


Returns true if this attribute can accept a connection of the given type.'''
        pass

    def setIndexMatters(self, state): 
        '''setIndexMatters(self, state)
Arguments:
	[in]	state = bool


If the attribute is an array, then this method specifies whether to force the user to specify an index when connecting to this attribute, or to use the next available index.'''
        pass

    def setUsedAsColor(self, state): 
        '''setUsedAsColor(self, state)
Arguments:
	[in]	state = bool


Sets whether this attribute should be presented as a color in the UI.'''
        pass

    def className(self): 
        '''className(self) -> char*

'''
        pass

    def setWritable(self, state): 
        '''setWritable(self, state)
Arguments:
	[in]	state = bool


Sets whether this attribute should be writable. If an attribute is writable, then it can be used as the destination in a dependency graph connection. If an attribute is not writable then  setAttr  commands will fail to change the attribute.'''
        pass

    def isReadable(self): 
        '''isReadable(self) -> bool
Returns: A boolean value indicating whether this attribute is readable


Returns true if this attribute is readable. If an attribute is readable, then it can be used as the source in a dependency graph connection.'''
        pass

    def setArray(self, state): 
        '''setArray(self, state)
Arguments:
	[in]	state = bool


Sets whether this attribute should have an array of data. This should be set to true if the attribute needs to accept multiple incoming connections.'''
        pass

    def isDynamic(self): 
        '''isDynamic(self) -> bool
Returns: A boolean value indicating whether this attribute is dynamic


Returns true if this attribute is a dynamic attribute.'''
        pass

class MFnBase:
    '''Function Set Base Class. Defines the interface for the API RTTI and Maya Object attachment methods common to all Function Set Classes.Implements the Function Set compatibility test methods for all Function Sets.The API provides access to Maya Objects as generic MObjects. Under the C++ class scheme MObjects simply have type MObject with no base or derived hierarchy. However, MObjects may be many different types of model or scene objects, from Attributes to Transforms, within Maya. This allows many different types of objects to be moved across or accessed through the API without undue concern on the part of plug-in developers for the type of object being manipulated.Since it is impractical to provide every applicable method on MObjects, the methods applicable to Maya Objects are encapsulated in Function Sets. Function Sets can be attached to compatible MObjects to provide an external interface to methods appropriate to that MObject. All Function Sets provide a method setObject() which attaches them to the specified Maya Object. Additionally, most Function Sets provide a version of their constructor which attaches the new Function Set to a specified MObject.The link between an MObject and the role it performs as a Maya scene or model object, as well as the compatibility between MObjects and Function Sets is managed by the API Run-Time Type Identification (RTTI) system. The two key concepts of this system are the Maya Object type and the Function Set type (both are MFn::Type). All MObjects have one and only one Maya Object type. All Function Sets have one and only one Function Set type. MObjects may, however, be compatible with many types of Function Sets. This compatibility follows the class hierarchy of the Function Sets. Thus an MObject with Maya Object type MFn::kNurbsSurface would be compatible with MFnNurbsSurface, MFnDagNode, MFnDependencyNode, MFnNamedObject and MFnBase.Any MObject can be queried with the MObject::hasFn() method to determine if it is comaptible with a given Function Set.The purpose of the Base Function Set (MFnBase) is to provide methods for determining whether or not a Function Set is compatible with a given Maya Object (MObject) type (MFn::Type) or a specific MObject. See: MFnBase::hasObj(MFn::Type) and MFnBase::hasObj(const MObject &)As well, this Function Set provides virtual methods for determining the type of a Function Set under the API RTTI system. '''
    def __init__(self):
        pass


    def hasObj(self, object): 
        '''hasObj(self, object) -> bool
Returns: true = Compatible 
false = Not Compatible 

Arguments:
	[in]	object = MObject


Determines whether or not the Function Set is compatible with the specified Maya Object within the API RTTI system.'''
        pass

    def object(self): 
        '''object(self) -> MObject
Returns: An MObject that references the object to which the Function Set is attached. If the function set is not attached to an MObject, MObject::kNullObj will be returned.


Returns the  MObject  that is attached to the Function Set.'''
        pass

    def type(self): 
        '''type(self) -> MFn.Type


Determines the type of the Function Set within the API RTTI system.'''
        pass

    def setObject(self, object): 
        '''setObject(self, object)
Arguments:
	[in]	object = MObject


Attaches the Function Set to the specified Maya Object.'''
        pass

class MFnBlinnShader:
    '''Manage Blinn shaders. MFnBlinnShader facilitates creation and manipulation of dependency graph nodes representing Blinn shaders. '''
    def __init__(self):
        pass


    def create(self, UIvisible): 
        '''create(self, UIvisible) -> MObject
Returns: MObject representing the new dependency node.

Arguments:
	[in]	UIvisible = bool


Creates a new blinn shader dependency graph node and adds it to the dependency graph. If the UIvisible parameter is true, the new node will be connected to the shader classification node (which allows the UI to recognize the node as a shader). If UIvisible is false, the node will be created in isolation.'''
        pass

    def className(self): 
        '''className(self) -> char*

'''
        pass

    def setSpecularRollOff(self, specular_rolloff): 
        '''setSpecularRollOff(self, specular_rolloff)
Arguments:
	[in]	specular_rolloff = float


Sets the value of the "specularRollOff" attribute of a shader node.'''
        pass

    def eccentricity(self): 
        '''eccentricity(self) -> float
Returns: The value of the "eccentricity" attribute of the shader node.


Retrieves the value of the "eccentricity" attribute of a blinn shader node. This attribute determines the size of the highlight produced by the shader.'''
        pass

    def setEccentricity(self, eccentr): 
        '''setEccentricity(self, eccentr)
Arguments:
	[in]	eccentr = float


Sets the value of the "eccentricity" attribute of a shader node.'''
        pass

    def type(self): 
        '''type(self) -> MFn.Type

'''
        pass

    def specularRollOff(self): 
        '''specularRollOff(self) -> float
Returns: The value of the "specularRollOff" attribute of the shader node.


Retrieves the value of the "specularRollOff" attribute of a blinn shader node. This attribute controls the increased oblique angle reflectivity of the shader.'''
        pass

class MFnCamera:
    '''Function set for cameras. Function set for creation, edit, and query of cameras.Many of the camera settings only affect the resulting rendered image. E.g. the F/Stop, shutter speed, the film related options, etc. '''
    def __init__(self):
        pass


    def kVerticalFilmFit(self):
        '''This is an enum of FilmFit.
Description: The same idea as horizontal fit, only applied vertically. Thus the digital image will match the film back exactly in height, but miss in width.
Value: 2'''
        pass

    def kOverscanFilmFit(self):
        '''This is an enum of FilmFit.
Description: Over-scanning the film gate in the camera view allows us to choreograph action outside of the frustum from within the camera view without having to resort to a dolly or zoom. This feature is also essential for animating image planes.
Value: 3'''
        pass

    def kInvalid(self):
        '''This is an enum of FilmFit.
Description: 
Value: 4'''
        pass

    def kHorizontalFilmFit(self):
        '''This is an enum of FilmFit.
Description: The digital image is made to fit the film back exactly in the horizontal direction. This then gives each pixel a horizontal size = (film back width) / (horizontal resolution). The pixel height is then = (pixel width) / (pixel aspect ratio). Now that the pixel has a size, resolution gives us a complete image. That image will match the film back exactly in width. It will almost never match in height, either being too tall or too short. By playing with the numbers you can get it pretty close though.
Value: 1'''
        pass

    def kFillFilmFit(self):
        '''This is an enum of FilmFit.
Description: The system calculates both horizontal and vertical fits and then applies the one that makes the digital image larger than the film back.
Value: 0'''
        pass

    class FilmFit:
        '''Non-functional class.  Values for this enum:
        kVerticalFilmFit
        kOverscanFilmFit
        kInvalid
        kHorizontalFilmFit
        kFillFilmFit
'''
        def __init__(self):
            pass

    def filmFitOffset(self): 
        '''filmFitOffset(self) -> double
Returns: The film fit offset as double.


Returns the film fit offset for the camera.'''
        pass

    def horizontalFilmOffset(self): 
        '''horizontalFilmOffset(self) -> double
Returns: The horizontal film offset for the camera


Returns the horizontal offset of the film. Unit used is inches.'''
        pass

    def postScale(self): 
        '''postScale(self) -> double
Returns: Post scale value.


Return the post projection matrix's post-scale value.'''
        pass

    def setFarClippingPlane(self, dFar): 
        '''setFarClippingPlane(self, dFar)
Arguments:
	[in]	dFar = double


Set the distances to the Far Clipping Plane.'''
        pass

    def setDisplayGateMask(self, displayGateMask): 
        '''setDisplayGateMask(self, displayGateMask)
Arguments:
	[in]	displayGateMask = bool


Activate shaded display of the film or resolution gate mask when looking through the camera. Does not activate the film or resolution gate display.'''
        pass

    def verticalShake(self): 
        '''verticalShake(self) -> double
Returns: The vertical film-based camera shake value for the camera


Change the vertical film-based camera shake value. Unit used is inches. This horizontal/vertical attribute pair acts identically to the film offset pair, but gives another point of input to that system. This allows film-based camera shake to be accessed conveniently and independently without disturbing any other film-offsetting techniques.'''
        pass

    def isDisplayFilmGate(self): 
        '''isDisplayFilmGate(self) -> bool
Returns: Boolean value: true The film gate is displayed, false otherwise.


Determines if the film gate icons are displayed when looking through the camera.'''
        pass

    def setCameraScale(self, scale): 
        '''setCameraScale(self, scale)
Arguments:
	[in]	scale = double


Sets the camera scale.'''
        pass

    def setEyePoint(self, eyeLocation, space): 
        '''setEyePoint(self, eyeLocation, space)
Arguments:
	[in]	eyeLocation = MPoint
	[in]	space = MSpace.Space


Positions the eye-point of the camera keeping the center of interest fixed in space. This method changed the orientation and translation of the camera's transform attributes as well as the center-of-interest distance.'''
        pass

    def isDepthOfField(self): 
        '''isDepthOfField(self) -> bool
Returns: Boolean value: true Depth of field is on, false otherwise.


Determines whether the depth of field calculation is performed for the camera. The depth of field calculation is used to give varying focus depending on the distance of the objects.'''
        pass

    def setFarFocusDistance(self, farFocusDistance): 
        '''setFarFocusDistance(self, farFocusDistance)
Arguments:
	[in]	farFocusDistance = double


Set the farthest distance within the well-focus region'''
        pass

    def setVerticalShake(self, vOffset): 
        '''setVerticalShake(self, vOffset)
Arguments:
	[in]	vOffset = double


Changes the vertical film-based camera shake value. Unit used is inches.'''
        pass

    def shakeEnabled(self): 
        '''shakeEnabled(self) -> bool
Returns: The horizontal film-based camera shake toggle value for the camera


Returns the toggle value for the camera shake enabled attribute. If this attribute is false, the horizontalShake and verticalShake values are ignored by the camera.'''
        pass

    def shakeOverscan(self): 
        '''shakeOverscan(self) -> double
Returns: The film-based camera shake overscan value for the camera


Returns the camera shake overscan value. Unit is a multiplier to the film aperture. This overscan is used to render a larger area than would be necessary if the camera were not shaking. This attribute will affect the output render.'''
        pass

    def preScale(self): 
        '''preScale(self) -> double
Returns: Pre scale value.


Return the post projection matrix's pre-scale value.'''
        pass

    def setOrthoWidth(self, orthoWidth): 
        '''setOrthoWidth(self, orthoWidth)
Arguments:
	[in]	orthoWidth = double


Sets a new width for the ortho camera. Bad values are ignored.'''
        pass

    def getFocalLengthLimits(self, min, max): 
        '''getFocalLengthLimits(self, min, max)
Arguments:
	[out]	min = double
	[out]	max = double


Returns the focal length limits for the camera.'''
        pass

    def viewDirection(self, space): 
        '''viewDirection(self, space) -> MVector
Returns: The view direction vector for the camera

Arguments:
	[in]	space = MSpace.Space


Returns the view direction for the camera.'''
        pass

    def getViewParameters(self, windowAspect, applyOverscan, applySqueeze, apertureX, apertureY, offsetX, offsetY): 
        '''getViewParameters(self, windowAspect, applyOverscan, applySqueeze, apertureX, apertureY, offsetX, offsetY)
Arguments:
	[in]	windowAspect = double
	[out]	apertureX = double
	[out]	apertureY = double
	[out]	offsetX = double
	[out]	offsetY = double
	[in]	applyOverscan = bool
	[in]	applySqueeze = bool


Computes and returns the intermediate viewing frustum parameters for the camera. The aperture and offset are used by getViewingFrustrum() and getRenderingFrustrum() to compute the extent (left, right, top, bottom) of the frustrum in the following manner:'''
        pass

    def setHorizontalFilmAperture(self, hFilmAperture): 
        '''setHorizontalFilmAperture(self, hFilmAperture)
Arguments:
	[in]	hFilmAperture = double


Change the horizontal size of the camera aperture. Unit used is inches.'''
        pass

    def shutterAngle(self): 
        '''shutterAngle(self) -> double
Returns: The shutter angle for the camera


Return the current shutter angle which is one of the variables used to compute motion blur. The shutter angle is specified in radians.'''
        pass

    def isMotionBlur(self): 
        '''isMotionBlur(self) -> bool
Returns: Boolean value: true Motion blur is on, false otherwise.


Determine if motion blur is on/off for the camera.'''
        pass

    def nearClippingPlane(self): 
        '''nearClippingPlane(self) -> double
Returns: The near clipping plane value for the camera


Returns the distance to the near clipping plane.'''
        pass

    def copyViewFrom(self, otherCamera): 
        '''copyViewFrom(self, otherCamera)
Arguments:
	[in]	otherCamera = MDagPath


Copy the camera settings related to the perspective from the given camera view.'''
        pass

    def setVerticalFilmOffset(self, vOffset): 
        '''setVerticalFilmOffset(self, vOffset)
Arguments:
	[in]	vOffset = double


Change the vertical offset of the film. Unit used is inches.'''
        pass

    def setVerticalLock(self, lockFlag): 
        '''setVerticalLock(self, lockFlag)
Arguments:
	[in]	lockFlag = bool


Sets the vertical lock to on or off for the camera.'''
        pass

    def setLensSqueezeRatio(self, aspectRatio): 
        '''setLensSqueezeRatio(self, aspectRatio)
Arguments:
	[in]	aspectRatio = double


Set the squeeze ratio of the lens. The aspect ratio is expressed as width/height.'''
        pass

    def setDisplayFilmGate(self, displayFilmGate): 
        '''setDisplayFilmGate(self, displayFilmGate)
Arguments:
	[in]	displayFilmGate = bool


Activate display of the film gate icons when looking through the camera.'''
        pass

    def setParallelView(self, parallelView): 
        '''setParallelView(self, parallelView)
Arguments:
	[in]	parallelView = bool


obsolete & no script support 
'''
        pass

    def setFilmTranslateH(self, translate): 
        '''setFilmTranslateH(self, translate)
Arguments:
	[in]	translate = double


Set the horizontal film translate.'''
        pass

    def setFStop(self, fStop): 
        '''setFStop(self, fStop)
Arguments:
	[in]	fStop = double


Sets the f-stop value for the camera.'''
        pass

    def setHorizontalFieldOfView(self, fov): 
        '''setHorizontalFieldOfView(self, fov)
Arguments:
	[in]	fov = double


Sets the horizontal field of view for the camera.'''
        pass

    def horizontalFilmAperture(self): 
        '''horizontalFilmAperture(self) -> double
Returns: The horizontal film aperture for the camera


Returns the horizontal film aperture for the camera.'''
        pass

    def overscan(self): 
        '''overscan(self) -> double
Returns: The percent of overscan


Returns the percent of overscan for this camera.'''
        pass

    def setFilmRollOrder(self, filmRollOrder): 
        '''setFilmRollOrder(self, filmRollOrder)
Arguments:
	[in]	filmRollOrder = MFnCamera.RollOrder


Assign the order in which the film back rotation is applied with respect to the pivot point.'''
        pass

    def verticalFilmOffset(self): 
        '''verticalFilmOffset(self) -> double
Returns: The vertical film offset for the camera


Change the vertical offset of the film. Unit used is inches.'''
        pass

    def setFilmTranslateV(self, translate): 
        '''setFilmTranslateV(self, translate)
Arguments:
	[in]	translate = double


Set the vertical film translate.'''
        pass

    def getFilmFrustum(self, distance, clipPlane): 
        '''getFilmFrustum(self, distance, clipPlane)
Arguments:
	[in]	distance = double
	[out]	clipPlane = MPoint4


No script support. 
'''
        pass

    def set(self, wsEyeLocation, wsViewDirection, wsUpDirection, horizFieldOfView, aspectRatio): 
        '''set(self, wsEyeLocation, wsViewDirection, wsUpDirection, horizFieldOfView, aspectRatio)
Arguments:
	[in]	wsEyeLocation = MPoint
	[in]	wsViewDirection = MVector
	[in]	wsUpDirection = MVector
	[in]	horizFieldOfView = double
	[in]	aspectRatio = double


Convenience routine to set the camera viewing parameters. The specified values should be in world space where applicable.'''
        pass

    def setShakeOverscanEnabled(self, enabled): 
        '''setShakeOverscanEnabled(self, enabled)
Arguments:
	[in]	enabled = bool


Changes the toggle value for the camera shake overscan enabled attribute. If this attribute is false, the shakeOverscan value is ignored by the camera.'''
        pass

    def tumblePivot(self): 
        '''tumblePivot(self) -> MPoint
Returns: The tumble pivot location of the camera


Returns the tumble pivot value for the camera. The pivot value will be in world space coordinates unless  usePivotAsLocalSpace()  is true in which case the pivot is a relative offset.'''
        pass

    def setMotionBlur(self, motionBlur): 
        '''setMotionBlur(self, motionBlur)
Arguments:
	[in]	motionBlur = bool


Turns motion blur on/off for the camera.'''
        pass

    def setFilmFit(self, filmFit): 
        '''setFilmFit(self, filmFit)
Arguments:
	[in]	filmFit = MFnCamera.FilmFit


Sets how the digital image is to be fitted to the film back.'''
        pass

    def filmTranslateH(self): 
        '''filmTranslateH(self) -> double
Returns: The horizontal translation amount.


Returns the horizontal film translate value. This value corresponds to the normalized viewport.'''
        pass

    def setAspectRatio(self, aspectRatio): 
        '''setAspectRatio(self, aspectRatio)
Arguments:
	[in]	aspectRatio = double


Set the aspect ratio of the View. The aspect ratio is expressed as width/height. This also modifies the entity's scale transformation to reflect the new aspect ratio.'''
        pass

    def setFocusDistance(self, distance): 
        '''setFocusDistance(self, distance)
Arguments:
	[in]	distance = double


Set the focus at a certain distance in front of the camera.'''
        pass

    def rightDirection(self, space): 
        '''rightDirection(self, space) -> MVector
Returns: The right direction vector for the camera

Arguments:
	[in]	space = MSpace.Space


Returns the right direction vector for the camera.'''
        pass

    def filmRollValue(self): 
        '''filmRollValue(self) -> double
Returns: Roll value in radians.


Returns the current roll value in radians.'''
        pass

    def setHorizontalRollPivot(self, horizontalRollPivot): 
        '''setHorizontalRollPivot(self, horizontalRollPivot)
Arguments:
	[in]	horizontalRollPivot = double


Set the horizontal roll pivot for film back roll.'''
        pass

    def stereoHIT(self): 
        '''stereoHIT(self) -> double
Returns: The stereo HIT value for this camera


Returns the camera stereo horizontal image translation (stereo HIT) value. Unit is inches. This has the same effect as the HFO attribute, but is intended as an input hook for use with stereo camera rigs.'''
        pass

    def setStereoHITEnabled(self, enabled): 
        '''setStereoHITEnabled(self, enabled)
Arguments:
	[in]	enabled = bool


Changes the toggle value for the stereo HIT enabled attribute. If this attribute is false, the stereoHIT value is ignored by the camera.'''
        pass

    def isVerticalLock(self): 
        '''isVerticalLock(self) -> bool
Returns: Boolean value: true Vertical lock is on, false otherwise.


Determines if vertical lock is turned on for the camera.'''
        pass

    def setClippingPlanes(self, ClippingPlanes): 
        '''setClippingPlanes(self, ClippingPlanes)
Arguments:
	[in]	ClippingPlanes = bool


Turn on/off manual setting of clip planes.'''
        pass

    def farFocusDistance(self): 
        '''farFocusDistance(self) -> double
Returns: The far focus distance for the camera


Returns the linear distance to the far focus plane.'''
        pass

    def setCenterOfInterest(self, dist): 
        '''setCenterOfInterest(self, dist)
Arguments:
	[in]	dist = double


Set the Center of Interest, which is defined to be a positive distance along the View Direction (i.e., "in front" of the Camera).'''
        pass

    def isClippingPlanes(self): 
        '''isClippingPlanes(self) -> bool
Returns: Boolean value: true manual clipping planes are activated, false otherwise.


Determines whether manual clipping planes are activated.'''
        pass

    def verticalRollPivot(self): 
        '''verticalRollPivot(self) -> double
Returns: Vertical roll pivot


Returns the vertical roll pivot's value.'''
        pass

    def setOverscan(self, overscan): 
        '''setOverscan(self, overscan)
Arguments:
	[in]	overscan = double


Set the percent of overscan for this camera.'''
        pass

    def horizontalShake(self): 
        '''horizontalShake(self) -> double
Returns: The horizontal film-based camera shake offset for the camera


Returns the horizontal offset of the film due to the shake attribute. Unit used is inches. This horizontal/vertical attribute pair acts identically to the film offset pair, but gives another point of input to that system. This allows film-based camera shake to be accessed conveniently and independently without disturbing any other film-offsetting techniques.'''
        pass

    def nearFocusDistance(self): 
        '''nearFocusDistance(self) -> double
Returns: The near focus distance for the camera


Returns the linear distance to the near focus plane.'''
        pass

    def setNearFarClippingPlanes(self, dNear, dFar): 
        '''setNearFarClippingPlanes(self, dNear, dFar)
Arguments:
	[in]	dNear = double
	[in]	dFar = double


Set the distances to the Near and Far Clipping Planes.'''
        pass

    def isOrtho(self): 
        '''isOrtho(self) -> bool
Returns: Boolean value: true The camera is orthographic, false otherwise.


Determines if the camera is in orthographic mode.'''
        pass

    def setShakeOverscan(self, overscan): 
        '''setShakeOverscan(self, overscan)
Arguments:
	[in]	overscan = double


Changes the camera shake overscan value. Unit is a multiplier to the film aperture size. This attribute will affect the output render.'''
        pass

    def filmFit(self): 
        '''filmFit(self) -> MFnCamera.FilmFit
Returns: The type of film fit.


Returns how the digital image is being fitted to the film back.'''
        pass

    def setHorizontalFilmOffset(self, hOffset): 
        '''setHorizontalFilmOffset(self, hOffset)
Arguments:
	[in]	hOffset = double


Change the horizontal offset of the film. Unit used is inches.'''
        pass

    def getRenderingFrustum(self, windowAspect, left, right, bottom, top): 
        '''getRenderingFrustum(self, windowAspect, left, right, bottom, top)
Arguments:
	[in]	windowAspect = double
	[out]	left = double
	[out]	right = double
	[out]	bottom = double
	[out]	top = double


Computes and returns the rendering frustum for the camera. This is the frustum that the maya renderer uses.'''
        pass

    def getViewingFrustum(self, windowAspect, applyOverscan, applySqueeze, left, right, bottom, top): 
        '''getViewingFrustum(self, windowAspect, applyOverscan, applySqueeze, left, right, bottom, top)
Arguments:
	[in]	windowAspect = double
	[out]	left = double
	[out]	right = double
	[out]	bottom = double
	[out]	top = double
	[in]	applyOverscan = bool
	[in]	applySqueeze = bool


Computes and returns the viewing frustum for the camera.'''
        pass

    def setHorizontalShake(self, hOffset): 
        '''setHorizontalShake(self, hOffset)
Arguments:
	[in]	hOffset = double


Change the horizontal film-based camera shake value. Unit used is inches.'''
        pass

    def farClippingPlane(self): 
        '''farClippingPlane(self) -> double
Returns: The far clipping plane value for the camera


Returns the distance to the far clipping plane.'''
        pass

    def verticalFilmAperture(self): 
        '''verticalFilmAperture(self) -> double
Returns: The vertical film aperture for the camera


Returns the vertical film aperture for the camera.'''
        pass

    def aspectRatio(self): 
        '''aspectRatio(self) -> double
Returns: The aspect ratio


Returns the aspect ratio for the camera.'''
        pass

    def cameraScale(self): 
        '''cameraScale(self) -> double
Returns: The scale value of the camera


Returns the camera scale.'''
        pass

    def eyePoint(self, space): 
        '''eyePoint(self, space) -> MPoint
Returns: The eye point location for the camera

Arguments:
	[in]	space = MSpace.Space


Returns the eye point for the camera.'''
        pass

    def filmTranslateV(self): 
        '''filmTranslateV(self) -> double
Returns: The vertical film translation.


Returns the vertical film translate value. This value corresponds to the normalized viewport, [-1,1].'''
        pass

    def getAspectRatioLimits(self, min, max): 
        '''getAspectRatioLimits(self, min, max)
Arguments:
	[out]	min = double
	[out]	max = double


Returns the minimum and maximum aspect ratio limits for the camera.'''
        pass

    def setVerticalFieldOfView(self, fov): 
        '''setVerticalFieldOfView(self, fov)
Arguments:
	[in]	fov = double


Sets the vertical field of view for the camera.'''
        pass

    def usePivotAsLocalSpace(self): 
        '''usePivotAsLocalSpace(self) -> bool
Returns: True if using local space tumbling for this camera, or false if using the current global tumble setting in Maya. See setUsePivotAsLocalSpace() for more details.


Returns the value of the local axis tumble setting for this camera.'''
        pass

    def filmRollOrder(self): 
        '''filmRollOrder(self) -> MFnCamera.RollOrder
Returns: The roll order


Returns the current roll order'''
        pass

    def orthoWidth(self): 
        '''orthoWidth(self) -> double
Returns: The orthographic width


Returns the orthographic projection width.'''
        pass

    def getFilmApertureLimits(self, min, max): 
        '''getFilmApertureLimits(self, min, max)
Arguments:
	[out]	min = double
	[out]	max = double


Returns the maximum and minimum film aperture limits for the camera.'''
        pass

    def setFilmRollValue(self, filmRollValue): 
        '''setFilmRollValue(self, filmRollValue)
Arguments:
	[in]	filmRollValue = double


Set the film roll value for film back.'''
        pass

    def focusDistance(self): 
        '''focusDistance(self) -> double
Returns: The focus distance for the camera


Returns the focus distance for the camera. This value sets the focus at a certain distance in front of the camera.'''
        pass

    def hasSamePerspective(self, otherCamera): 
        '''hasSamePerspective(self, otherCamera) -> bool
Returns: Boolean value: true Specified camera has same perspective as this camera, false otherwise.

Arguments:
	[in]	otherCamera = MDagPath


Returns true if the camera has same perspective settings as the given camera.'''
        pass

    def focalLength(self): 
        '''focalLength(self) -> double
Returns: The focal length for the camera


Returns the focal length for the camera.'''
        pass

    def setVerticalRollPivot(self, verticalRollPivot): 
        '''setVerticalRollPivot(self, verticalRollPivot)
Arguments:
	[in]	verticalRollPivot = double


Set the vertical roll pivot for film back roll.'''
        pass

    def create(self, parent): 
        '''create(self, parent) -> MObject
Returns: The transform parenting the new camera

Arguments:
	[in]	parent = MObject


Creates a perspective camera. A parent can be specified for the new camera, otherwise a transform is created.'''
        pass

    def setTumblePivot(self, point): 
        '''setTumblePivot(self, point)
Arguments:
	[in]	point = MPoint


The tumble pivot is used for non-local tumble operations. It is in world space for "tumble pivot" mode and relative space for "local axis" mode (see setUsePivotAsLocalSpace).'''
        pass

    def setNearClippingPlane(self, dNear): 
        '''setNearClippingPlane(self, dNear)
Arguments:
	[in]	dNear = double


Set the distances to the Near Clipping Plane.'''
        pass

    def postProjectionMatrix(self, context): 
        '''postProjectionMatrix(self, context) -> MFloatMatrix
Returns: The film roll matrix.

Arguments:
	[in]	context = MDGContext


Returns the post projection matrix used to compute film roll on the film back plane.'''
        pass

    def setDepthOfField(self, depthOfField): 
        '''setDepthOfField(self, depthOfField)
Arguments:
	[in]	depthOfField = bool


Specifies whether the depth of field calculation is performed for the camera. The depth of field calculation is used to give varying focus depending on the distance of the objects.'''
        pass

    def type(self): 
        '''type(self) -> MFn.Type

'''
        pass

    def horizontalRollPivot(self): 
        '''horizontalRollPivot(self) -> double
Returns: The horizontal roll pivot value.


Returns the current horizontal roll pivot value.'''
        pass

    def fStop(self): 
        '''fStop(self) -> double
Returns: The F/Stop value for the camera


Returns the f-stop value for the camera.'''
        pass

    def setShakeEnabled(self, enabled): 
        '''setShakeEnabled(self, enabled)
Arguments:
	[in]	enabled = bool


Changes the toggle value for the camera shake enabled attribute. If this attribute is false, the horizontalShake and verticalShake values are ignored by the camera.'''
        pass

    def setPreScale(self, sf): 
        '''setPreScale(self, sf)
Arguments:
	[in]	sf = double


Set the pre scale value.'''
        pass

    def stereoHITEnabled(self): 
        '''stereoHITEnabled(self) -> bool
Returns: The camera stereo HIT toggle value for the camera


Returns the toggle value for the stereo HIT enabled attribute. If this attribute is false, the stereoHIT value is ignored by the camera.'''
        pass

    def setShutterAngle(self, shutterAngle): 
        '''setShutterAngle(self, shutterAngle)
Arguments:
	[in]	shutterAngle = double


Change the current shutter angle which is one of the variables used to compute motion blur. The shutterAngle is specified in radians.'''
        pass

    def setUsePivotAsLocalSpace(self, how): 
        '''setUsePivotAsLocalSpace(self, how)
Arguments:
	[in]	how = bool


Local space tumbling specifies that when the camera is tumbled, the camera will rotate about its local axis, offset by the tumblePivot. The effect is like that of tilting the camera on a tripod. This per-camera setting overrides whatever tumble mode is defined globally in Maya.'''
        pass

    def lensSqueezeRatio(self): 
        '''lensSqueezeRatio(self) -> double
Returns: The lens squeeze ratio for the camera


Returns the lens squeeze ratio for the camera.'''
        pass

    def setFilmFitOffset(self, filmFitOffset): 
        '''setFilmFitOffset(self, filmFitOffset)
Arguments:
	[in]	filmFitOffset = double


Set the film fit offset for the camera.'''
        pass

    def upDirection(self, space): 
        '''upDirection(self, space) -> MVector
Returns: The up direction vector for this camera

Arguments:
	[in]	space = MSpace.Space


Returns the up direction vector for the camera.'''
        pass

    def setIsOrtho(self, orthoState, useDist): 
        '''setIsOrtho(self, orthoState, useDist)
Arguments:
	[in]	orthoState = bool
	[in]	useDist = double


Switch the camera in and out of orthographic mode. When the switch happens, the camera has to calculate a new fov or ortho width, each of which is based on the other and a set distance. The caller can specify the distance; otherwise the center of interest is used.'''
        pass

    def centerOfInterestPoint(self, space): 
        '''centerOfInterestPoint(self, space) -> MPoint
Returns: The center of interest location of the camera

Arguments:
	[in]	space = MSpace.Space


Returns the center of interest point for the camera.'''
        pass

    def shakeOverscanEnabled(self): 
        '''shakeOverscanEnabled(self) -> bool
Returns: The camera shake overscan toggle value for the camera


Returns the toggle value for the camera shake overscan attribute. If this attribute is false, the shakeOverscan value is ignored by the camera.'''
        pass

    def setNearFocusDistance(self, nearFocusDistance): 
        '''setNearFocusDistance(self, nearFocusDistance)
Arguments:
	[in]	nearFocusDistance = double


Set the nearest distance within the well-focus region'''
        pass

    def projectionMatrix(self, context): 
        '''projectionMatrix(self, context) -> MFloatMatrix
Returns: The projection matrix

Arguments:
	[in]	context = MDGContext


Returns the orthographic or perspective projection matrix for the camera. The projection matrix that maya's software renderer uses is almost identical to the OpenGL projection matrix. The difference is that maya uses a left hand coordinate system and so the entries [2][2] and [3][2] are negated.'''
        pass

    def computeDepthOfField(self, nearLimit): 
        '''computeDepthOfField(self, nearLimit)
Arguments:
	[in]	nearLimit = double


 Parameters: 
 
 [in]   nearLimit   
 
 
 Returns: Status code 
 Status Codes: 
 MS::kSuccess  The method was successful  
 MS::kFailure  An object error has occurred  
 
 
'''
        pass

    def setPostScale(self, sf): 
        '''setPostScale(self, sf)
Arguments:
	[in]	sf = double


Set the post scale value.'''
        pass

    def horizontalFieldOfView(self): 
        '''horizontalFieldOfView(self) -> double
Returns: The horizontal field of view for the camera


Returns the horizontal field of view for the camera.'''
        pass

    def setCenterOfInterestPoint(self, centerOfInterest, space): 
        '''setCenterOfInterestPoint(self, centerOfInterest, space)
Arguments:
	[in]	centerOfInterest = MPoint
	[in]	space = MSpace.Space


Positions the center-of-interest of the camera keeping the eye-point fixed in space. This method changed the orientation and translation of the camera's transform attributes as well as the center-of-interest distance.'''
        pass

    def setFocalLength(self, focalLength): 
        '''setFocalLength(self, focalLength)
Arguments:
	[in]	focalLength = double


Sets the focal length for the camera.'''
        pass

    def setStereoHIT(self, hit): 
        '''setStereoHIT(self, hit)
Arguments:
	[in]	hit = double


Changes the camera stereo horizontal image translation (stereo HIT) value. Unit is inches. This has the same effect as the HFO attribute, but is intended as an input hook for use with stereo camera rigs.'''
        pass

    def setVerticalFilmAperture(self, vFilmAperture): 
        '''setVerticalFilmAperture(self, vFilmAperture)
Arguments:
	[in]	vFilmAperture = double


Change the vertical size of the camera aperture. Unit used is inches.'''
        pass

    def getPortFieldOfView(self, width, height, horizontalFOV, verticalFOV): 
        '''getPortFieldOfView(self, width, height, horizontalFOV, verticalFOV)
Arguments:
	[in]	width = int
	[in]	height = int
	[out]	horizontalFOV = double
	[out]	verticalFOV = double


Compute the horizontal and vertical field of view in radians from the given viewport width and height.'''
        pass

    def centerOfInterest(self): 
        '''centerOfInterest(self) -> double
Returns: center of interest distance value


Return the linear distance from the camera's eye point to the center of interest.'''
        pass

    def verticalFieldOfView(self): 
        '''verticalFieldOfView(self) -> double
Returns: The vertical field of view for the camera


Returns the vertical field of view for the camera.'''
        pass

class MFnComponent:
    '''Base class for component function sets. This is the base class for all function sets which deal with component objects.Components are MObjects which hold index information for shapes. The component object does not contain any information about the shape, it just contains index values and type information.Components can be marked as complete meaning that the component represents a complete set of indices from 0 to numElements-1;Components come is 3 varieties based upon the dimensions of the index. The types are single, double, and triple indexed. Examples of these types are mesh vertices (single indexed), nurbs surface CVs (double indexed), and lattice points (triple indexed).To create, edit, or query a specific type of component, use the derived classes MFnSingleIndexedComponent, MFnDoubleIndexedComponent, and MFnTripleIndexedComponent. '''
    def __init__(self):
        pass


    def componentType(self): 
        '''componentType(self) -> MFn.Type
Returns: The type


Returns the  MFn  type of the component.'''
        pass

    def weight(self, index): 
        '''weight(self, index) -> MWeight
Returns: The element weight data.

Arguments:
	[in]	index = int


Return the weight data for a given element within this component. Note that this method does not return external weight data (e.g. deformer weights stored in separate attributes).'''
        pass

    def setComplete(self, complete): 
        '''setComplete(self, complete)
Arguments:
	[in]	complete = bool


Sets the complete state of the component.'''
        pass

    def hasWeights(self): 
        '''hasWeights(self) -> bool


Query this component for the existance of attached weight data. Weight data will be added to a component as part of soft selection and/or symmetry. Note that this method does not test for the existance of external weight information (e.g. deformer weights stored in separate attributes).'''
        pass

    def isComplete(self): 
        '''isComplete(self) -> bool
Returns: True if this component is complete, false otherwise


Returns the complete state of the component.'''
        pass

    def className(self): 
        '''className(self) -> char*

'''
        pass

    def elementCount(self): 
        '''elementCount(self) -> int
Returns: The number of elements


Returns the number of elements that this component contains.'''
        pass

    def isEmpty(self): 
        '''isEmpty(self) -> bool
Returns: True if empty, false otherwise


Determines if this component is empty, i.e. there are no index elements.'''
        pass

    def isEqual(self, component): 
        '''isEqual(self, component) -> bool
Returns: True if the components are equal, false otherwise

Arguments:
	[in]	component = MObject


Compares this component with the given component.'''
        pass

    def type(self): 
        '''type(self) -> MFn.Type

'''
        pass

class MFnComponentListData:
    '''Component list function set for dependency node data. MFnComponentListData allows the creation and manipulation of component list (represented as MObjects) data objects for use in the dependency graph.If a user written dependency node either accepts or produces MObjects containing component lists, then this class is used to extract or create the data that comes from or goes to other dependency graph nodes. To access it, the MDataHandle::data method is used to get an MObject for the data and this should then be used to initialize an instance of MFnComponentListData. '''
    def __init__(self):
        pass


    def __getitem__(self, index): 
        '''__getitem__(self, index) -> MObject
Returns: The indicated component 

Arguments:
	[in]	index = int


Extract the indicated component from the const instance. No checking is done by this class to ensure that the index is valid - use the length method to determine the size of the array. If the instance is not attached to an  MObject , this method will return  MObject::kNullObj .'''
        pass

    def clear(self): 
        '''clear(self)

Remove all components from the component list'''
        pass

    def add(self, obj): 
        '''add(self, obj)
Arguments:
	[in]	obj = MObject


Add the given component to the component list.'''
        pass

    def remove(self, index): 
        '''remove(self, index)
Arguments:
	[in]	index = int


Remove the indicated component from the component list.'''
        pass

    def className(self): 
        '''className(self) -> char*

'''
        pass

    def length(self): 
        '''length(self) -> int
Returns: The number of components in the instance


Return the number of components in the instance.'''
        pass

    def has(self, obj): 
        '''has(self, obj) -> bool

Arguments:
	[in]	obj = MObject


Determine if the instance of the component list contains the component represented by the given  MObject .'''
        pass

    def type(self): 
        '''type(self) -> MFn.Type

'''
        pass

    def create(self): 
        '''create(self) -> MObject
Returns: The newly created MObject 


Create a new  MObject , attach it to this instance, and initialize it to contain an empty component list.'''
        pass

class MFnCompoundAttribute:
    '''Compound attribute function set. MFnCompoundAttribute is the function set for compound dependency node attributes.Compound attributes allow the grouping of related attributes into a larger unit. It is possible to connect to a compound attribute as a whole, or to any of the individual children.For example, the three attributes RED, GREEN, and BLUE could be grouped into a compound attribute of type COLOR. It is then possible to connect two COLOR attributes together. This removes the need to connect each child explicitly.A second use for compound attributes is when there are multi attributes that relate to each other on an element-by-element basis. An example of this is the weighted matrix node that has a multi attribute with matrices that must be matched with the multi attribute that provides the weights for each matrix. '''
    def __init__(self):
        pass


    def addChild(self, child): 
        '''addChild(self, child)
Arguments:
	[in]	child = MObject


Add a child attribute under this compound attribute.'''
        pass

    def getAddAttrCmds(self, useLongNames, cmds): 
        '''getAddAttrCmds(self, useLongNames, cmds)
Arguments:
	[out]	cmds = MStringArray
	[in]	useLongNames = bool


Returns a string array containing the  addAttr  commands which would be required to recreate the attribute and all of its descendents on a node.'''
        pass

    def create(self, full, brief): 
        '''create(self, full, brief) -> MObject

Arguments:
	[in]	full = MString
	[in]	brief = MString


Creates a new compound attribute.'''
        pass

    def numChildren(self): 
        '''numChildren(self) -> int
Returns: The number of children


Returns the number of child attributes that this compound attribute has.'''
        pass

    def className(self): 
        '''className(self) -> char*

'''
        pass

    def removeChild(self, child): 
        '''removeChild(self, child)
Arguments:
	[in]	child = MObject


Remove a child attribute from this compound attribute.'''
        pass

    def child(self, index): 
        '''child(self, index) -> MObject
Returns: The child attribute

Arguments:
	[in]	index = int


Get a child of this compound attribute.'''
        pass

    def type(self): 
        '''type(self) -> MFn.Type

'''
        pass

class MFnContainerNode:
    '''container function set MFnContainerNode is the function set for creating, querying and editing containers.Maya uses container nodes to bundle sets of related nodes together with a published attribute list that defined the primary interface to those nodes. This class allows you to query information about container nodes in the Maya scene. '''
    def __init__(self):
        pass


    def getParentContainer(self, parent): 
        '''getParentContainer(self, parent)
Arguments:
	[out]	parent = MObject


Return the parent container, if there is one. Otherwise return an empty  MObject'''
        pass

    def className(self): 
        '''className(self) -> char*

'''
        pass

    def getPublishedPlugs(self, publishedPlugs, publishedNames): 
        '''getPublishedPlugs(self, publishedPlugs, publishedNames)
Arguments:
	[out]	publishedPlugs = MPlugArray
	[out]	publishedNames = MStringArray


Return two arrays: the first contains the plugs that have been published on this container. The second contains that published names for those plugs. There is a one-to-one correspondence between the plugs in the first array and the strings in the second.'''
        pass

    def getMembers(self, members): 
        '''getMembers(self, members)
Arguments:
	[out]	members = MObjectArray


Return an array of the nodes included in this container.'''
        pass

    def type(self): 
        '''type(self) -> MFn.Type

'''
        pass

    def getSubcontainers(self, subcontainers): 
        '''getSubcontainers(self, subcontainers)
Arguments:
	[out]	subcontainers = MObjectArray


Return an array of the container nodes included in this container.'''
        pass

class MFnDagNode:
    '''DAG Node Function Set. Provides methods for attaching Function Sets to, querying, and adding children to DAG Nodes. Particularly useful when used in conjunction with the DAG Iterator class (MItDag).The MFnDagNode function set is used to query and set the attributes of nodes in the DAG (Directed Acyclic Graph). The DAG is a graph that describes the hierarchy of the objects in the model. At each level of the hierarchy there is a four by four transformation matrix that affects all of the objects beneath it in the DAG.In the DAG, geometry objects (also known as shapes) do not have transformation information associated with them. Only transform nodes have actual transform matrices (see MFnTransform).Each node that exists in the DAG is also a dependency node that exists in the dependency graph. This makes it possible to control the attributes of a DAG node based on calculations performed by dependency nodes.There are two ways to specify a DAG node in Maya. The first is to use an MObject handle, which acts as a pointer to a specific node in the DAG. Given only an MObject, it is not possible to do world space operations on a DAG node because there may be more than one path through the DAG to any given node. In other words, it is not possible to identify a particular instance only given an MObject.In many cases it is preferable to use a DAG path (MDagPath) to specify a DAG node. A DAG path always refers to a specific instance of an object. This makes it possible to perform unambiguous world space transformations.It is also possible to iterate over the nodes in the DAG using a DAG iterator (MItDag). '''
    def __init__(self):
        pass


    def addChild(self, child, index, keepExistingParents): 
        '''addChild(self, child, index, keepExistingParents)
Arguments:
	[in]	child = MObject
	[in]	index = int
	[in]	keepExistingParents = bool


Makes the given DAG Node a child of the DAG Node to which this instance of the Function Set is attached.'''
        pass

    def setInstanceable(self, how): 
        '''setInstanceable(self, how)
Arguments:
	[in]	how = bool


Sets whether or not the DAG node is instanceable. If the node is marked as noninstanceable, then if Maya attempts to create instances on the node the instancing operation will not succeed and instead an error will be reported. A node cannot be marked non-instanceable if it or any of its children are currently instanced.  MS::kFailure  will be returned it this occurs. The default instanceable state for newly created nodes if true, meaning that nodes can be instanced by default.'''
        pass

    def fullPathName(self): 
        '''fullPathName(self) -> MString
Returns: The full path name


Return a string representing the full path from the root of the dag to this object.'''
        pass

    def parentCount(self): 
        '''parentCount(self) -> int
Returns: Number of parent Nodes.


Determines the number of parent Nodes of the Node. Used to determine the upper bound for the parent index (max index = parentCount-1).'''
        pass

    def setObjectColor(self, index): 
        '''setObjectColor(self, index)
Arguments:
	[in]	index = int


Sets the index for the current user defined inactive color used by the node.'''
        pass

    def dagRoot(self): 
        '''dagRoot(self) -> MObject
Returns: The DAG root


Determines the root of the first DAG Path to the DAG Node attached to the Function Set.'''
        pass

    def hasParent(self, node): 
        '''hasParent(self, node) -> bool
Returns: Boolean value: true if the node is a parent, false otherwise.

Arguments:
	[in]	node = MObject


Determines whether or not the given Node is a parent of the DAG Node attached to the Function Set.'''
        pass

    def setIntermediateObject(self, isIntermediate): 
        '''setIntermediateObject(self, isIntermediate)
Arguments:
	[in]	isIntermediate = bool


Sets whether this object is an intermediate in a geometry calculation.'''
        pass

    def setObject(self, object): 
        '''setObject(self, object)
Arguments:
	[in]	object = MObject


No script support. 
'''
        pass

    def inUnderWorld(self): 
        '''inUnderWorld(self) -> bool


Determines whether or not the DAG Node is an underworld node. (An example of an underworld node is a  curve on surface .)'''
        pass

    def create(self, type, name, parent): 
        '''create(self, type, name, parent) -> MObject
Returns: A pointer to the new dependency node object or the transform added above it.

Arguments:
	[in]	type = MString
	[in]	name = MString
	[in]	parent = MObject


Creates a new DAG node with the given type tag. The new node is placed into the DAG.'''
        pass

    def partialPathName(self): 
        '''partialPathName(self) -> MString
Returns: The partial path name


Return a string representing the partial path from the root of the dag to this object.'''
        pass

    def getPath(self, path): 
        '''getPath(self, path)
Arguments:
	[out]	path = MDagPath


Returns a DAG Path to the DAG Node attached to the Function Set. The difference between this method and the method  dagPath  below is that this one will not fail if the function set is not attached to a dag path, it will always return  a  path to the node.  dagPath  will fail if the function set is not attached to a dag path.'''
        pass

    def duplicate(self, instance, leafInstance): 
        '''duplicate(self, instance, leafInstance) -> MObject
Returns: A reference to the newly created node.

Arguments:
	[in]	instance = bool
	[in]	leafInstance = bool


This method duplicates the DAG hierarchy rooted at the current node. The copy will have the same parent, if any, as the original node.'''
        pass

    def inModel(self): 
        '''inModel(self) -> bool


Determines whether or not the DAG Node is in the model.'''
        pass

    def removeChildAt(self, index): 
        '''removeChildAt(self, index)
Arguments:
	[in]	index = int


Removes the child at the given index from the parent. Once the child is removed, all children at higher indices would shift 1 position to the left.'''
        pass

    def isParentOf(self, node): 
        '''isParentOf(self, node) -> bool
Returns: Boolean value: true is a parent, false otherwise.

Arguments:
	[in]	node = MObject


Determines whether or not the DAG Node attached to the Function Set is a parent of the given node.'''
        pass

    def isInstanceable(self): 
        '''isInstanceable(self) -> bool
Returns: true if the DAG node is instanceable


Returns true if the DAG node can be instanced, and false otherwise.'''
        pass

    def type(self): 
        '''type(self) -> MFn.Type

'''
        pass

    def childCount(self): 
        '''childCount(self) -> int
Returns: Number of child Nodes.


Determines the number of child Nodes of the Node. Used to determine the upper bound for the child index (max index = childCount-1).'''
        pass

    def isInstancedAttribute(self, attribute): 
        '''isInstancedAttribute(self, attribute) -> bool
Returns: A boolean value indicating whether the attribute is instanced

Arguments:
	[in]	attribute = MObject


Returns true if the specified attribute is instanced. An instanced attribute is an array attribute whose index depends upon which instance of the node is being referred to.'''
        pass

    def instanceCount(self, total): 
        '''instanceCount(self, total) -> int
Returns: Number of instances (direct or indirect according to indirect instance flag).

Arguments:
	[in]	total = bool


Determines the number of times the Node attached to the Function Set is instanced.'''
        pass

    def transformationMatrix(self): 
        '''transformationMatrix(self) -> MMatrix
Returns: Object space transformation matrix.


Returns the object space transformation matrix for this DAG node. In general, only transform nodes have matrices associated with them. Nodes such as shapes (geometry nodes) do not have transform matrices.'''
        pass

    def parent(self, i): 
        '''parent(self, i) -> MObject
Returns: The parent Node for the given index.

Arguments:
	[in]	i = int


Queries the DAG Node attached to the Function Set for the parent Node corresponding to the given index.'''
        pass

    def enum(self): 
        '''enum(self) -> anonymous


Anonymous enum to store constant values. 
'''
        pass

    def usingObjectColor(self): 
        '''usingObjectColor(self) -> bool
Returns: True if using the user defined inactive object color


Determines whether or not the user defined inactive color will be used for the node, or whether the default inactive color will be used.'''
        pass

    def child(self, i): 
        '''child(self, i) -> MObject
Returns: The child Node for the given index.

Arguments:
	[in]	i = int


Queries the DAG Node attached to the Function Set for the child Node corresponding to the given index.'''
        pass

    def boundingBox(self): 
        '''boundingBox(self) -> MBoundingBox
Returns: The bounding box for the dag node


Returns the bounding box for the dag node in object space.'''
        pass

    def hasChild(self, node): 
        '''hasChild(self, node) -> bool
Returns: Boolean value: true if the node is a child, false otherwise.

Arguments:
	[in]	node = MObject


Determines whether or not the given Node is a child of the DAG Node attached to the Function Set.'''
        pass

    def isChildOf(self, node): 
        '''isChildOf(self, node) -> bool
Returns: Boolean value: true is a child, false otherwise.

Arguments:
	[in]	node = MObject


Determines whether or not the DAG Node attached to the Function Set is a child of the given node.'''
        pass

    def className(self): 
        '''className(self) -> char*

'''
        pass

    def removeChild(self, child): 
        '''removeChild(self, child)
Arguments:
	[in]	child = MObject


Removes the given DAG Node from the parent. Once the child is removed, all children at higher indices would shift 1 position to the left.'''
        pass

    def setUseObjectColor(self, useObjectColor): 
        '''setUseObjectColor(self, useObjectColor)
Arguments:
	[in]	useObjectColor = bool


Sets whether or not the user defined inactive object color will be used.'''
        pass

    def getAllPaths(self, paths): 
        '''getAllPaths(self, paths)
Arguments:
	[out]	paths = MDagPathArray


Determines all DAG Paths to the DAG Node attached to the Function Set.'''
        pass

    def objectColor(self): 
        '''objectColor(self) -> int
Returns: Index for current user defined inactive color (0 - 7)


Determines the index for the current user defined inactive color used by the node. Valid indices are from 0 to 7.'''
        pass

    def dagPath(self): 
        '''dagPath(self) -> MDagPath
Returns: An MDagPath that references the object to which the Function Set is attached. If the function set is not attached to a dag path an uninitialized MDagPath will be returned.


Returns the DagPath to which the Function Set is attached. The difference between this method and the method  getPath  above is that this one will fail if the function set is not attached to a dag path.  getPath  will find a dag path if the function set is not attached to one.'''
        pass

    def isInstanced(self, indirect): 
        '''isInstanced(self, indirect) -> bool
Returns: Boolean value: true if the node is instanced (directly or indirectly according to indirect instance flag), false otherwise.

Arguments:
	[in]	indirect = bool


Determines whether the DAG Node attached to the Function Set is directly or indirectly instanced.'''
        pass

    def isIntermediateObject(self): 
        '''isIntermediateObject(self) -> bool
Returns: Boolean value determining whether this is an intermediate object


Returns true if this object is an intermediate in a geometry calculation.'''
        pass

class MFnData:
    '''Parent class for dependency graph data function sets.MFnData is the parent class for all dependency graph data function sets. Conceptually, data objects are what flow through the connections in the dependency graph.Each node in the dependency graph has a data block associated with it. The data block holds the data objects for all of the node's attributes (see MDataBlock). The data block is only available during the compute method of a node. A data handle (MDataHandle) can be created to access a particular attribute's data inside of the data block.Once a data handle is obtained, it is possible to get the data object from it. This is only necessary for heavier data structures such as geometry or strings. Simple numeric data can be manipulated straight through the data handle.Note: using kDynSweptGeometry data requires that a plug-in or stand alone API application be linked with the OpenMayaFX library. '''
    def __init__(self):
        pass


    def className(self): 
        '''className(self) -> char*

'''
        pass

    def type(self): 
        '''type(self) -> MFn.Type

'''
        pass

    def kVectorArray(self):
        '''This is an enum of Type.
Description: Vector Array, use
Value: 10'''
        pass

    def kSphere(self):
        '''This is an enum of Type.
Description: Sphere, use
Value: 16'''
        pass

    def kMatrix(self):
        '''This is an enum of Type.
Description: Matrix, use
Value: 5'''
        pass

    def kPluginGeometry(self):
        '''This is an enum of Type.
Description: Plugin Geometry, use
Value: 3'''
        pass

    def kDynSweptGeometry(self):
        '''This is an enum of Type.
Description: SweptGeometry, use
Value: 18'''
        pass

    def kLattice(self):
        '''This is an enum of Type.
Description: Lattice, use
Value: 13'''
        pass

    def kNumeric(self):
        '''This is an enum of Type.
Description: Numeric, use
Value: 1'''
        pass

    def kPointArray(self):
        '''This is an enum of Type.
Description: Point Array, use
Value: 9'''
        pass

    def kString(self):
        '''This is an enum of Type.
Description: String, use
Value: 4'''
        pass

    def kPlugin(self):
        '''This is an enum of Type.
Description: Plugin Blind Data, use
Value: 2'''
        pass

    def kNurbsCurve(self):
        '''This is an enum of Type.
Description: Nurbs Curve, use
Value: 14'''
        pass

    def kIntArray(self):
        '''This is an enum of Type.
Description: Int Array, use
Value: 8'''
        pass

    def kDynArrayAttrs(self):
        '''This is an enum of Type.
Description: ArrayAttrs, use
Value: 17'''
        pass

    def kSubdSurface(self):
        '''This is an enum of Type.
Description: Subdivision Surface, use
Value: 19'''
        pass

    def kNObject(self):
        '''This is an enum of Type.
Description: nObject data, use
Value: 20'''
        pass

    def kLast(self):
        '''This is an enum of Type.
Description: Last value. It does not represent real data, but can be used to loop on all possible types
Value: 21'''
        pass

    def kStringArray(self):
        '''This is an enum of Type.
Description: String Array, use
Value: 6'''
        pass

    def kNurbsSurface(self):
        '''This is an enum of Type.
Description: Nurbs Surface, use
Value: 15'''
        pass

    def kComponentList(self):
        '''This is an enum of Type.
Description: Component List, use
Value: 11'''
        pass

    def kInvalid(self):
        '''This is an enum of Type.
Description: Invalid value.
Value: 0'''
        pass

    def kDoubleArray(self):
        '''This is an enum of Type.
Description: Double Array, use
Value: 7'''
        pass

    def kMesh(self):
        '''This is an enum of Type.
Description: Mesh, use
Value: 12'''
        pass

    class Type:
        '''Non-functional class.  Values for this enum:
        kVectorArray
        kSphere
        kMatrix
        kPluginGeometry
        kDynSweptGeometry
        kLattice
        kNumeric
        kPointArray
        kString
        kPlugin
        kNurbsCurve
        kIntArray
        kDynArrayAttrs
        kSubdSurface
        kNObject
        kLast
        kStringArray
        kNurbsSurface
        kComponentList
        kInvalid
        kDoubleArray
        kMesh
'''
        def __init__(self):
            pass

class MFnDependencyNode:
    '''Dependency node function set. MFnDependencyNode allows the creation and manipulation of dependency graph nodes. Traversal of the dependency graph is possible using the getConnections method.This function set does not support creation or removal of connections. MDGModifier should be used for that purpose. '''
    def __init__(self):
        pass


    def typeId(self): 
        '''typeId(self) -> MTypeId
Returns: The type id of this node


Returns the type id of this node. The type is is the 4 byte code that is used in the binary file format to identify the type of this node.'''
        pass

    def classification(self, nodeTypeName): 
        '''classification(self, nodeTypeName) -> MString
Returns: The classification string. If the node does not have an associated classification, an empty string will be returned. 

Arguments:
	[in]	nodeTypeName = MString


Retrieves the  classification string  for a node type. This is a string that is used in dependency nodes that are also shaders to provide more detailed  type  information to the rendering system. See the documentation for the MEL commands  getClassification  and  listNodeTypes  for information on the strings that can be provided.'''
        pass

    def removeAttribute(self, attribute, type): 
        '''removeAttribute(self, attribute, type)
Arguments:
	[in]	attribute = MObject
	[in]	type = MFnDependencyNode.MAttrClass


Remove an attribute from a node.'''
        pass

    def deallocateFlag(self, pluginName, flag): 
        '''deallocateFlag(self, pluginName, flag)
Arguments:
	[in]	pluginName = MString
	[in]	flag = int


Deallocates a node  flag  which was previously allocated by a call to  allocateFlag . The flag subsequently becomes available for reallocation and use by someone else.'''
        pass

    def attribute(self, attrName): 
        '''attribute(self, attrName) -> MObject
Returns: A pointer to the attribute

Arguments:
	[in]	attrName = MString


Finds the attribute of this node that has the given name.'''
        pass

    def dgCallbacks(self, timerType, callbackName, value): 
        '''dgCallbacks(self, timerType, callbackName, value)
Arguments:
	[in]	timerType = MFnDependencyNode.MdgTimerType
	[in]	callbackName = MStringArray
	[in]	value = MDoubleArray


Node callbacks that occur when timing is enabled get logged with the node and can be queried via this method. See the dgCallbackIds method for getting a further breakdown of the time for an individual callback on this node.'''
        pass

    def dgTimerReset(self): 
        '''dgTimerReset(self)

The function resets the dependency graph timers and counters for this node to zero. Note that this method does not start or stop timing, it only resets the values to zero. If you want to turn on timing, use the method  dgTimerOn() . If you want to turn off timing, use  dgTimerOff() .'''
        pass

    def addAttribute(self, attr, type): 
        '''addAttribute(self, attr, type)
Arguments:
	[in]	attr = MObject
	[in]	type = MFnDependencyNode.MAttrClass


Add a new attibute to this node. Note that this operation will fail if the given  type  parameter is not  MFnDependencyNode::kLocalDynamicAttr .'''
        pass

    def dgCallbackIds(self, timerType, callbackName, callbackId, value): 
        '''dgCallbackIds(self, timerType, callbackName, callbackId, value)
Arguments:
	[in]	timerType = MFnDependencyNode.MdgTimerType
	[in]	callbackName = MString
	[in]	callbackId = MCallbackIdArray
	[in]	value = MDoubleArray


This method provides a further breakdown of the per-callback time returned via  dgCallbacks()  by returning the data on a per-callbackId basis. We define a "callback" to be an event withing Maya that "callback methods" can be registered with to be invoked when the given event occurs. The registered client information is called a "callbackId". There can be multiple callbackIds registered with a given callback, and a callbackId can be shared amongst multiple nodes or multiple callbacks.'''
        pass

    def typeName(self): 
        '''typeName(self) -> MString
Returns: The type name of this node


Returns the type name of this node. The string returned is the name of the node type as it is used in the ascii file format.'''
        pass

    def reorderedAttribute(self, index): 
        '''reorderedAttribute(self, index) -> MObject
Returns: A pointer to the attribute

Arguments:
	[in]	index = int


Some nodes, such as the various animCurve nodes, require that their attributes be set in a specific order for proper operation. Usually this ordering is only important when the node is being created during file I/O.'''
        pass

    def isDefaultNode(self): 
        '''isDefaultNode(self) -> bool
Returns: Boolean value: true if the node is default, false otherwise.


Returns true if the node is a default node.'''
        pass

    def isNewAttribute(self, attr): 
        '''isNewAttribute(self, attr) -> bool

Arguments:
	[in]	attr = MObject


Indicates whether or not the specified attribute was added to this node within the current scene.'''
        pass

    def userNode(self): 
        '''userNode(self) -> MPxNode
Returns: A pointer to the user data (NULL if not a plug-in node)


If the function set's node is a plug-in node, then this method will extract the  MPxNode  pointer from it. This method should only be used on node types that are provided by the plug-in calling this method.'''
        pass

    def create(self, type, name): 
        '''create(self, type, name) -> MObject
Returns: A pointer to the new dependency node object

Arguments:
	[in]	type = MString
	[in]	name = MString


Creates a new dependency node with the given type. The new node is placed into the dependency graph.'''
        pass

    def isFromReferencedFile(self): 
        '''isFromReferencedFile(self) -> bool
Returns: Boolean value: true if the node came from a referenced file, false otherwise.


Indicates whether or not this node came from a referenced file. If it did, the node will be marked as read-only in the scene and changes to the node's attributes will be saved in the main scene file, not the referenced from from which the node came.'''
        pass

    def deallocateAllFlags(self, pluginName): 
        '''deallocateAllFlags(self, pluginName)
Arguments:
	[in]	pluginName = MString


Deallocates all of the node flags which are currently allocated to the specified plugin. The deallocated flags immediately become available for use by any plugin.'''
        pass

    def isLocked(self): 
        '''isLocked(self) -> bool
Returns: Boolean value: 
true if the node is locked, false otherwise.


Indicates whether or not this node is locked. See the  setLocked  method for more information on what it means for a node to be locked.'''
        pass

    def setFlag(self, flag, state): 
        '''setFlag(self, flag, state)
Arguments:
	[in]	flag = int
	[in]	state = bool


Sets the  state  of the specified  flag  for the node.'''
        pass

    def kInvalidAttr(self):
        '''This is an enum of MAttrClass.
Description: 
Value: 4'''
        pass

    def kGlobalDynamicAttr(self):
        '''This is an enum of MAttrClass.
Description: Dynamically added, applies to all nodes of this type.
Value: 1'''
        pass

    def kNormalAttr(self):
        '''This is an enum of MAttrClass.
Description: Static attribute which is part of the original definition for this node type.
Value: 3'''
        pass

    def kLocalDynamicAttr(self):
        '''This is an enum of MAttrClass.
Description: Dynamically added, only applies to this specific node.
Value: 2'''
        pass

    class MAttrClass:
        '''Non-functional class.  Values for this enum:
        kInvalidAttr
        kGlobalDynamicAttr
        kNormalAttr
        kLocalDynamicAttr
'''
        def __init__(self):
            pass

    def getAffectedByAttributes(self, attr, affectedByAttributes): 
        '''getAffectedByAttributes(self, attr, affectedByAttributes)
Arguments:
	[in]	attr = MObject
	[out]	affectedByAttributes = MObjectArray


Returns an array of attributes that affect the attribute passed in,  attr . That is, when one of the attributes in  affectedByAttributes  is marked dirty (changed) then  attr  will also be marked dirty. For nodes defined in plug-ins this call returns all those attributes that were marked as affecting the given one via the  MPxNode::attributeAffects  call.'''
        pass

    def attributeClass(self, attribute): 
        '''attributeClass(self, attribute) -> MFnDependencyNode.MAttrClass
Returns: The class of the attribute. If the node does not have the specified attribute, then kInvalidAttr is returned as the class.

Arguments:
	[in]	attribute = MObject


Returns the class (normal, local dynamic, global dynamic) of the specified attribute.'''
        pass

    def hasUniqueName(self): 
        '''hasUniqueName(self) -> bool
Returns: Boolean value: 
true if the node's name is unique within scene, false otherwise.


Indicates whether or not this node's name is unique within the scene.'''
        pass

    def type(self): 
        '''type(self) -> MFn.Type

'''
        pass

    def isShared(self): 
        '''isShared(self) -> bool
Returns: Boolean value: true if the node is shared, false otherwise.


Indicates whether or not this node is shared. This comes into play when you attempt to create a new node with the same name as an existing node. If the existing node is shared, then no new node will be created. If the existing node is not shared, then the new node will be created and given a different name.'''
        pass

    def canBeWritten(self): 
        '''canBeWritten(self) -> bool
Returns: Boolean value: true if the node can be written, false otherwise.


Returns true if the node can be written/exported to scene files.'''
        pass

    def setLocked(self, lock): 
        '''setLocked(self, lock)
Arguments:
	[in]	lock = bool


Locks or unlocks this node.'''
        pass

    def setName(self, name): 
        '''setName(self, name) -> MString
Returns: The new name of the node.

Arguments:
	[in]	name = MString


Sets the name of this node.'''
        pass

    def dgTimerQueryState(self): 
        '''dgTimerQueryState(self) -> MFnDependencyNode.MdgTimerState
Returns: The node's timer's current on/off state.


The function returns the current on/off state of the node's timer.'''
        pass

    def kTimerOff(self):
        '''This is an enum of MdgTimerState.
Description: 
Value: 0'''
        pass

    def kTimerInvalidState(self):
        '''This is an enum of MdgTimerState.
Description: 
Value: 3'''
        pass

    def kTimerUninitialized(self):
        '''This is an enum of MdgTimerState.
Description: 
Value: 2'''
        pass

    def kTimerOn(self):
        '''This is an enum of MdgTimerState.
Description: 
Value: 1'''
        pass

    class MdgTimerState:
        '''Non-functional class.  Values for this enum:
        kTimerOff
        kTimerInvalidState
        kTimerUninitialized
        kTimerOn
'''
        def __init__(self):
            pass

    def parentNamespace(self): 
        '''parentNamespace(self) -> MString
Returns: The name of the namespace in which this node exists. This will be a colon separated path. If the object is in the root namespace, then an empty string will be returned.


Returns the name of the namespace in which this node resides. Namespaces are often used when importing files to prevent name collisions.'''
        pass

    def attributeCount(self): 
        '''attributeCount(self) -> int
Returns: The attribute count


Returns the number of attributes that this node has.'''
        pass

    def kTimerMetric_computeDuringCallback(self):
        '''This is an enum of MdgTimerMetric.
Description: Time spent in this node's compute while executing node callbacks on any node.
Value: 7'''
        pass

    def kTimerMetric_fetch(self):
        '''This is an enum of MdgTimerMetric.
Description: Time spent fetching data from plugs.
Value: 4'''
        pass

    def kTimerMetric_callbackNotViaAPI(self):
        '''This is an enum of MdgTimerMetric.
Description: Time spent in callbacks not registered through the API (i.e internal Maya callbacks).
Value: 6'''
        pass

    def kTimerMetric_computeNotDuringCallback(self):
        '''This is an enum of MdgTimerMetric.
Description: Time spent in this nodes compute when not executing any node callbacks on any nodes.
Value: 8'''
        pass

    def kTimerMetric_callback(self):
        '''This is an enum of MdgTimerMetric.
Description: Time spent within node callbacks for this node.
Value: 0'''
        pass

    def kTimerMetric_draw(self):
        '''This is an enum of MdgTimerMetric.
Description: Time spent drawing this node.
Value: 3'''
        pass

    def kTimerMetric_callbackViaAPI(self):
        '''This is an enum of MdgTimerMetric.
Description: Time spent in callbacks which were registered through the API.
Value: 5'''
        pass

    def kTimerMetric_dirty(self):
        '''This is an enum of MdgTimerMetric.
Description: Time spent propogating dirty messages from this node.
Value: 2'''
        pass

    def kTimerMetric_compute(self):
        '''This is an enum of MdgTimerMetric.
Description: Time spent within the compute method for this node.
Value: 1'''
        pass

    class MdgTimerMetric:
        '''Non-functional class.  Values for this enum:
        kTimerMetric_computeDuringCallback
        kTimerMetric_fetch
        kTimerMetric_callbackNotViaAPI
        kTimerMetric_computeNotDuringCallback
        kTimerMetric_callback
        kTimerMetric_draw
        kTimerMetric_callbackViaAPI
        kTimerMetric_dirty
        kTimerMetric_compute
'''
        def __init__(self):
            pass

    def hasAttribute(self, attrName): 
        '''hasAttribute(self, attrName) -> bool

Arguments:
	[in]	attrName = MString


Returns true if the node already has an attribute with the given name.'''
        pass

    def getAliasAttr(self, force): 
        '''getAliasAttr(self, force) -> MObject
Returns: The MObject corresponding to the alias attribute.

Arguments:
	[in]	force = bool


The function returns the alias attribute list; returns NULL if it doesn't exist. If the value of argument 'force' is true, an alias attribute is created if one doesn't exist.'''
        pass

    def setAlias(self, alias, name, plug, add): 
        '''setAlias(self, alias, name, plug, add) -> bool
Returns: Boolean indicating if the alias has been set properly.

Arguments:
	[in]	alias = MString
	[in]	name = MString
	[in]	plug = MPlug
	[in]	add = bool


The function sets the alias attribute.'''
        pass

    def setDoNotWrite(self, flag): 
        '''setDoNotWrite(self, flag)
Arguments:
	[in]	flag = bool


Use this method to mark the "do not write" state of this node. If set, this node will not be saved when the Maya model is written out.'''
        pass

    def plugsAlias(self, plug): 
        '''plugsAlias(self, plug) -> MString
Returns: Name of the alias attribute.

Arguments:
	[in]	plug = MPlug


The function returns the name of the alias on whose attribute the given plug is created.'''
        pass

    def name(self): 
        '''name(self) -> MString
Returns: The name of this node


Returns the name of this node. Note that if the object the instance of this class is attached to is  data  instead of being in the graph (ie. the object was created by one of the MFn*Data function sets, or was passed to an  MPxNode::compute  function in a data block) then the  name  method will not work.'''
        pass

    def getAffectedAttributes(self, attr, affectedAttributes): 
        '''getAffectedAttributes(self, attr, affectedAttributes)
Arguments:
	[in]	attr = MObject
	[out]	affectedAttributes = MObjectArray


Returns an array of attributes that are affected by the attribute passed in. That is, when the given attribute,  attr  is marked dirty (changed) all the  affectedAttributes  attributes will also be marked dirty. For nodes defined in plug-ins this call returns all those attributes that were marked as being affected by the given one via the  MPxNode::attributeAffects  call.'''
        pass

    def findPlug(self, attrName, wantNetworkedPlug): 
        '''findPlug(self, attrName, wantNetworkedPlug) -> MPlug
Returns: The plug

Arguments:
	[in]	attrName = MString
	[in]	wantNetworkedPlug = bool


Attempt to find a plug for the given attribute. This method will first try to find the networked version of the plug if requested. The networked version of a plug is one that currently exists in the dependency graph at a particular connection point. If a networked version is not found, then a standard non-networked plug is returned.'''
        pass

    def getAliasList(self, strArray): 
        '''getAliasList(self, strArray) -> bool
Returns: Boolean value: true if any alias was found.

Arguments:
	[out]	strArray = MStringArray


The function sets a pointer to the list of all attribute aliases for this node.'''
        pass

    def dgTimer(self, timerMetric, timerType): 
        '''dgTimer(self, timerMetric, timerType) -> double
Returns: Value of the timer in seconds for types of kTimerType_self and kTimerType_inclusive, and as a simple count for kTimerType_count.

Arguments:
	[in]	timerMetric = MFnDependencyNode.MdgTimerMetric
	[in]	timerType = MFnDependencyNode.MdgTimerType


The function returns the specified timer value for the current node. This is the total amount of time spent performing the requested operation since the timer was last reset (see  dgTimerReset()  for details). There are numerous timers per node and these are referenced by the metric and the timer type.'''
        pass

    def findAlias(self, alias, attrObj): 
        '''findAlias(self, alias, attrObj) -> bool
Returns: Boolean indicating if the alias was found.

Arguments:
	[in]	alias = MString
	[in]	attrObj = MObject


The function looks for an aliased attribute on this node with the given name'''
        pass

    def className(self): 
        '''className(self) -> char*

'''
        pass

    def getConnections(self, array): 
        '''getConnections(self, array)
Arguments:
	[out]	array = MPlugArray


Get all of the current connections to this node as an array of plugs.'''
        pass

    def pluginName(self): 
        '''pluginName(self) -> MString
Returns: The name of the plug-in


Returns the name of the plug-in this MFnDependendencyNode was defined in. The name returned is the name of the plug-in on disk, and may contain pathname separators (such as `/') and drive letters (e.g. C:). If this object is not an MFnDependency node, then  MS::kFailure  is returned instead.'''
        pass

    def dgTimerOff(self): 
        '''dgTimerOff(self)

The function stops the timing of dependency graph evaluation for this node'''
        pass

    def dgTimerOn(self): 
        '''dgTimerOn(self)

The function starts the timing for this node. Note that this does not reset the timers and counters on the node, it merely activates the timing mechanism within Maya and subsequent timing values are added to the current timer and counter values. If you also want the counters to be reset, use the method  dgTimerReset() .'''
        pass

    def isFlagSet(self, flag): 
        '''isFlagSet(self, flag) -> bool
Returns: Current state of the flag

Arguments:
	[in]	flag = int


Retrieves the current state of the specified  flag  for a node.'''
        pass

    def allocateFlag(self, pluginName): 
        '''allocateFlag(self, pluginName) -> int
Returns: The newly-allocated flag.

Arguments:
	[in]	pluginName = MString


Allocates a node flag for sole use by the caller. Note that the flag is not specific to any one node but is made available to the caller on all nodes. Furthermore, node flags only persist for the duration of the current Maya session: they are not saved with the scene.'''
        pass

    def kTimerType_self(self):
        '''This is an enum of MdgTimerType.
Description: Time spent performing an operation, not including any time spent by child operations. For example, if we are drawing a node and that requires a compute, self time will only include the time spent drawing and not the compute time. Self time measures wall-clock time as opposed to CPU time and the values are in seconds.
Value: 0'''
        pass

    def kTimerType_inclusive(self):
        '''This is an enum of MdgTimerType.
Description: Time spent performing an operation including all time spent by child operations. For example, if we are drawing a node and that requires a compute, inclusive time is the time for the draw plus compute. Inclusive time measure wall-clock time as opposed to CPU time and the values are in seconds.
Value: 1'''
        pass

    def kTimerType_count(self):
        '''This is an enum of MdgTimerType.
Description: The number of operations that occurred. Ideally we should return an integer when this timer type is queried, but there are two advantages to using a double. 1) it keeps the interface consistent and 2) integer has a fixed upper bound of roughly four billion so using a double allows us to exceed this.
Value: 2'''
        pass

    class MdgTimerType:
        '''Non-functional class.  Values for this enum:
        kTimerType_self
        kTimerType_inclusive
        kTimerType_count
'''
        def __init__(self):
            pass

class MFnDirectionalLight:
    '''Manage Directional Light dependency nodes. MFnDirectionalLight facilitates creation and manipulation of dependency nodes representing direction lights. '''
    def __init__(self):
        pass


    def className(self): 
        '''className(self) -> char*

'''
        pass

    def create(self, parent, UIvisible, wantTransform): 
        '''create(self, parent, UIvisible, wantTransform) -> MObject
Returns: MObject representing the new dependency node.

Arguments:
	[in]	parent = MObject
	[in]	UIvisible = bool
	[in]	wantTransform = bool


Creates a new directional light dependency graph node and adds it to the dependency graph. If the UIvisible parameter is true, the new node will be connected to the light classification node (which allows the UI to recognize the node as a light) and added to the default light list. If UIvisible is false, the node will be created in isolation.'''
        pass

    def setShadowAngle(self, shadow_angle): 
        '''setShadowAngle(self, shadow_angle)
Arguments:
	[in]	shadow_angle = float


Sets the value of the "shadowAngle" attribute of a directional light node.'''
        pass

    def type(self): 
        '''type(self) -> MFn.Type

'''
        pass

    def shadowAngle(self): 
        '''shadowAngle(self) -> float
Returns: The value of the "shadowAngle" attribute of the light node.


Retrieves the value of the "shadowAngle" attribute of a directional light node. This attribute represents an angular divergence from the direction vector of the light used to calculate soft shadows.'''
        pass

class MFnDoubleArrayData:
    '''double array function set for dependency node data. MFnDoubleArrayData allows the creation and manipulation of MDoubleArray data objects for use in the dependency graph.If a user written dependency node either accepts or produces MDoubleArrays, then this class is used to extract or create the data that comes from or goes to other dependency graph nodes. The MDataHandle::type method will return kDoubleArray when data of this type is present. To access it, the MDataHandle::data method is used to get an MObject for the data and this should then be used to initialize an instance of MFnDoubleArrayData. '''
    def __init__(self):
        pass


    def set(self, array): 
        '''set(self, array)
Arguments:
	[in]	array = MDoubleArray


Set the instance to contain the doubles defined in the given  MDoubleArray .'''
        pass

    def __getitem__(self, index): 
        '''__getitem__(self, index) -> double
Returns: The indicated double 

Arguments:
	[in]	index = int


Extract the indicated double from the const instance. No checking is done by this class to ensure that the index is valid - use the length method to determine the size of the array. If the instance is not attached to an  MObject , this method will return an double containing zero.'''
        pass

    def create(self, arr): 
        '''create(self, arr) -> MObject
Returns: The newly created MObject 

Arguments:
	[in]	arr = MDoubleArray


Create a new  MObject , attach it to this instance, and initialize it to contain the data from the given  MDoubleArray .'''
        pass

    def copyTo(self, dest): 
        '''copyTo(self, dest)
Arguments:
	[out]	dest = MDoubleArray


Copy all the doubles in the instance into the given  MDoubleArray .'''
        pass

    def className(self): 
        '''className(self) -> char*

'''
        pass

    def length(self): 
        '''length(self) -> int
Returns: The number of doubles in the instance 


Return the number of doubles in the instance.'''
        pass

    def array(self): 
        '''array(self) -> MDoubleArray
Returns: A copy of the MDoubleArray held in this instance 


Return an  MDoubleArray  containing the double array currently operated upon by the function set. The  MDoubleArray  returned by this method is editable, so any changes to the return instance also affects the  MObject  operated upon by this function set.'''
        pass

    def type(self): 
        '''type(self) -> MFn.Type

'''
        pass

class MFnDoubleIndexedComponent:
    '''Double indexed component function set. This function set allows you to create, edit, and query double indexed components. Double indexed components store 2 dimensional index values. '''
    def __init__(self):
        pass


    def getCompleteData(self, maxU, maxV): 
        '''getCompleteData(self, maxU, maxV)
Arguments:
	[out]	maxU = int
	[out]	maxV = int


Returns the number of elements for the complete component. A complete component means that all elements are selected.'''
        pass

    def getElement(self, index, uIndex, vIndex): 
        '''getElement(self, index, uIndex, vIndex)
Arguments:
	[in]	index = int
	[out]	uIndex = int
	[out]	vIndex = int


Get the specified element from the component.'''
        pass

    def getElements(self, uIndices, vIndices): 
        '''getElements(self, uIndices, vIndices)
Arguments:
	[out]	uIndices = MIntArray
	[out]	vIndices = MIntArray


Get all of the element indices from the component.'''
        pass

    def create(self, compType): 
        '''create(self, compType) -> MObject
Returns: The new component

Arguments:
	[in]	compType = MFn.Type


Create a double indexed component of the given type. Allowable types are'''
        pass

    def addElements(self, uIndices, vIndices): 
        '''addElements(self, uIndices, vIndices)
Arguments:
	[in]	uIndices = MIntArray
	[in]	vIndices = MIntArray


Add the specified elements to the component.'''
        pass

    def className(self): 
        '''className(self) -> char*

'''
        pass

    def setCompleteData(self, maxU, maxV): 
        '''setCompleteData(self, maxU, maxV)
Arguments:
	[in]	maxU = int
	[in]	maxV = int


Marks the component as complete (meaning all items are selected) and uses the argument to identify the total number of elements selected. If the component should contain N element indices, then the range would be [0,N-1].'''
        pass

    def type(self): 
        '''type(self) -> MFn.Type

'''
        pass

    def addElement(self, uIndex, vIndex): 
        '''addElement(self, uIndex, vIndex)
Arguments:
	[in]	uIndex = int
	[in]	vIndex = int


Add the specified element to the component.'''
        pass

class MFnEnumAttribute:
    '''Enumerated attribute function set. Function set for enumerated attributes. These attributes accept fields as input. Each field consists of a short and its associated string, which is a descriptive name for the field. '''
    def __init__(self):
        pass


    def setDefault(self, fieldString): 
        '''setDefault(self, fieldString)
Arguments:
	[in]	fieldString = MString


Set a new default value for this enum attribute.'''
        pass

    def addField(self, fieldString, index): 
        '''addField(self, fieldString, index)
Arguments:
	[in]	fieldString = MString
	[in]	index = short


Add a field (a string/index pair) to the enumeration'''
        pass

    def create(self, fullName, briefName, defaultValue): 
        '''create(self, fullName, briefName, defaultValue) -> MObject
Returns: The newly created enumerated attribute object.

Arguments:
	[in]	fullName = MString
	[in]	briefName = MString
	[in]	defaultValue = short


Creates an enumerated attribute object.'''
        pass

    def className(self): 
        '''className(self) -> char*

'''
        pass

    def getDefault(self, index): 
        '''getDefault(self, index)
Arguments:
	[out]	index = short


Get the default value for the enum attribute.'''
        pass

    def fieldIndex(self, fieldString): 
        '''fieldIndex(self, fieldString) -> short
Returns: The index associated with the given descriptive string.

Arguments:
	[in]	fieldString = MString


Retrieve the index associated with a given string.'''
        pass

    def fieldName(self, index): 
        '''fieldName(self, index) -> MString
Returns: The descriptive string corresponding to the given index

Arguments:
	[in]	index = short


Retrieve the string associated with a given index'''
        pass

    def getMin(self, minValue): 
        '''getMin(self, minValue)
Arguments:
	[out]	minValue = short


Return the minimum value for this attribute.'''
        pass

    def getMax(self, maxValue): 
        '''getMax(self, maxValue)
Arguments:
	[out]	maxValue = short


Return the maximum value for this attribute.'''
        pass

    def type(self): 
        '''type(self) -> MFn.Type

'''
        pass

    def defaultValue(self): 
        '''defaultValue(self) -> MString
Returns: the string value for the default enum


Get the default value for the enum attribute.'''
        pass

class MFnExpression:
    '''Expression function set. This class is used to create, edit, and query expression nodes. '''
    def __init__(self):
        pass


    def isAnimated(self): 
        '''isAnimated(self) -> bool
Returns: true expression will be evaluated whenever time changes 
false


If this is  true , then the expression will be evaluated whenever time changes, regardless of whether the other inputs have changed.'''
        pass

    def setUnitConversion(self, conversion): 
        '''setUnitConversion(self, conversion)
Arguments:
	[in]	conversion = MFnExpression.UnitConversion


Set the unit conversion options for the expression node.'''
        pass

    def kNone(self):
        '''This is an enum of UnitConversion.
Description: Do not do any unit conversion.
Value: 1'''
        pass

    def kAngularOnly(self):
        '''This is an enum of UnitConversion.
Description: Only convert angular units.
Value: 2'''
        pass

    def kAll(self):
        '''This is an enum of UnitConversion.
Description: Convert all units.
Value: 0'''
        pass

    class UnitConversion:
        '''Non-functional class.  Values for this enum:
        kNone
        kAngularOnly
        kAll
'''
        def __init__(self):
            pass

    def expression(self): 
        '''expression(self) -> MString
Returns: The expression string


Gets the expression string for this expression node.'''
        pass

    def create(self, expression, object): 
        '''create(self, expression, object) -> MObject
Returns: The expression node

Arguments:
	[in]	expression = MString
	[in]	object = MObject


This method creates and returns a dependency node for a given expression.'''
        pass

    def className(self): 
        '''className(self) -> char*

'''
        pass

    def setDefaultObject(self, object): 
        '''setDefaultObject(self, object)
Arguments:
	[in]	object = MObject


Sets the "default" object for the expression. This allows the expression writer to not type the object name for frequently-used objects.'''
        pass

    def evaluate(self, result): 
        '''evaluate(self, result)
Arguments:
	[out]	result = MDoubleArray


Evaluate this expression and return the result.'''
        pass

    def setAnimated(self, value): 
        '''setAnimated(self, value)
Arguments:
	[in]	value = bool


Sets the way in which the expression is evaluated.'''
        pass

    def unitConversion(self): 
        '''unitConversion(self) -> MFnExpression.UnitConversion
Returns: The unit conversion state for this node


Get the unit conversion status for the expression node.'''
        pass

    def getDefaultObject(self, object): 
        '''getDefaultObject(self, object)
Arguments:
	[out]	object = MObject


Gets the "default" object for the expression. Not all expressions have a default object. If there is no default object for the expression, the object will be set to MObject::kNullObject and the return status will indicate success. This is a completely legal case that the calling code should check for before blindly using the returned object.'''
        pass

    def setExpression(self, expression): 
        '''setExpression(self, expression)
Arguments:
	[in]	expression = MString


Sets the expression string for this expression node.'''
        pass

    def type(self): 
        '''type(self) -> MFn.Type

'''
        pass

class MFnGenericAttribute:
    '''Generic attribute function set. MFnGenericAttribute is a function set for attributes that can accept several types of data. A generic attribute is similar to a typed attribute (MFnTypedAttribute) except that it has a list of types that it considers valid.If the attribute will only take one type of data then it is more efficient to use one of the other attribute function sets such as MFnTypedAttribute or MFnNumericAttribute. '''
    def __init__(self):
        pass


    def removeNumericDataAccept(self, oldType): 
        '''removeNumericDataAccept(self, oldType)
Arguments:
	[in]	oldType = MFnNumericData.Type


Remove one of the types that this attribute can accept.'''
        pass

    def removeAccept(self, id): 
        '''removeAccept(self, id)
Arguments:
	[in]	id = MTypeId


Remove one of the types that this attribute can accept. This method takes the type id (iff tag) of the data objects that can no longer be accepted.'''
        pass

    def create(self, full, brief): 
        '''create(self, full, brief) -> MObject

Arguments:
	[in]	full = MString
	[in]	brief = MString


Creates a new generic attribute.'''
        pass

    def className(self): 
        '''className(self) -> char*

'''
        pass

    def removeDataAccept(self, oldType): 
        '''removeDataAccept(self, oldType)
Arguments:
	[in]	oldType = MFnData.Type


Remove one of the types that this attribute can accept.'''
        pass

    def addAccept(self, id): 
        '''addAccept(self, id)
Arguments:
	[in]	id = MTypeId


Add a new connection type that this attribute can accept. This method takes the type id (iff tag) of the data objects that can be accepted.'''
        pass

    def addDataAccept(self, newType): 
        '''addDataAccept(self, newType)
Arguments:
	[in]	newType = MFnData.Type


Add a new connection type that this attribute can accept.'''
        pass

    def type(self): 
        '''type(self) -> MFn.Type

'''
        pass

    def addNumericDataAccept(self, newType): 
        '''addNumericDataAccept(self, newType)
Arguments:
	[in]	newType = MFnNumericData.Type


Add a new connection type that this attribute can accept.'''
        pass

class MFnGeometryData:
    '''Geometry data function set. This class is the function set for geometry data.Geometry data adds matrix and grouping (set) information to regular data and is used to pass geometry types such as mesh, lattice, and NURBS shape data through DG connections.User defined geometry data types (MPxGeometryData) are also supported by this class.The matrix within geometry data is the matrix used to convert the object into local space. '''
    def __init__(self):
        pass


    def objectGroup(self, index): 
        '''objectGroup(self, index) -> int
Returns: The id of the i'th object group

Arguments:
	[out]	index = int


This method returns the id of the i'th object group contained by the object.'''
        pass

    def removeObjectGroup(self, id): 
        '''removeObjectGroup(self, id)
Arguments:
	[in]	id = int


This method removes an object group with the given id from the object.'''
        pass

    def objectGroupType(self, id): 
        '''objectGroupType(self, id) -> MFn.Type
Returns: The type of the specified object group component

Arguments:
	[in]	id = int


This method returns the type of the component that the object group with the given id contains.'''
        pass

    def matrixIsNotIdentity(self): 
        '''matrixIsNotIdentity(self) -> bool
Returns: True if the matrix for the geometry is NOT the identity, false otherwise


Return true if the matrix is different from identity.'''
        pass

    def setMatrix(self, matrix): 
        '''setMatrix(self, matrix)
Arguments:
	[in]	matrix = MMatrix


Reset the matrix the the specified matrix and set the identity flag if the new matrix is the identity.'''
        pass

    def addObjectGroup(self, id): 
        '''addObjectGroup(self, id)
Arguments:
	[in]	id = int


This method adds an object group to the object with the given id.'''
        pass

    def hasObjectGroup(self, id): 
        '''hasObjectGroup(self, id) -> bool
Returns: True is there is an object group with the given id, false otherwise

Arguments:
	[in]	id = int


This method returns true if an object group with the given id is contained in the data.'''
        pass

    def removeObjectGroupComponent(self, id, component): 
        '''removeObjectGroupComponent(self, id, component)
Arguments:
	[in]	id = int
	[in]	component = MObject


This method removes the members of the given Tcomponent to the object group with the given id.'''
        pass

    def objectGroupCount(self): 
        '''objectGroupCount(self) -> int
Returns: The number of object groups


This method returns the number of object groups contained by the object.'''
        pass

    def className(self): 
        '''className(self) -> char*

'''
        pass

    def addObjectGroupComponent(self, id, component): 
        '''addObjectGroupComponent(self, id, component)
Arguments:
	[in]	id = int
	[in]	component = MObject


This method adds the members of the given component to the object group with the given id.'''
        pass

    def copyObjectGroups(self, inGeom): 
        '''copyObjectGroups(self, inGeom)
Arguments:
	[in]	inGeom = MObject


Copies the object groups from the given geometry data object.'''
        pass

    def setObjectGroupComponent(self, id, component): 
        '''setObjectGroupComponent(self, id, component)
Arguments:
	[in]	id = int
	[in]	component = MObject


This method sets the members of the object group with the given id to be only those in the given component.'''
        pass

    def changeObjectGroupId(self, sourceId, destId): 
        '''changeObjectGroupId(self, sourceId, destId)
Arguments:
	[in]	sourceId = int
	[in]	destId = int


This method changes the id of the object group with the given id to the new id.'''
        pass

    def objectGroupComponent(self, id): 
        '''objectGroupComponent(self, id) -> MObject
Returns: A component containing the members of the specified object group

Arguments:
	[in]	id = int


This method returns a component which contains the members of the object group with the given id.'''
        pass

    def type(self): 
        '''type(self) -> MFn.Type

'''
        pass

    def matrixIsIdentity(self): 
        '''matrixIsIdentity(self) -> bool
Returns: True if the matrix for the geometry is identity, false otherwise


Return true if the matrix is the identity.'''
        pass

    def getMatrix(self, matrix): 
        '''getMatrix(self, matrix)
Arguments:
	[out]	matrix = MMatrix


Get the matrix associated with the geometry data.'''
        pass

class MFnIntArrayData:
    '''int array function set for dependency node data. MFnIntArrayData allows the creation and manipulation of MIntArray data objects for use in the dependency graph.If a user written dependency node either accepts or produces MIntArrays, then this class is used to extract or create the data that comes from or goes to other dependency graph nodes. The MDataHandle::type method will return kIntArray when data of this type is present. To access it, the MDataHandle::data method is used to get an MObject for the data and this should then be used to initialize an instance of MFnIntArrayData. '''
    def __init__(self):
        pass


    def set(self, array): 
        '''set(self, array)
Arguments:
	[in]	array = MIntArray


Set the instance to contain the integers defined in the given  MIntArray .'''
        pass

    def __getitem__(self, index): 
        '''__getitem__(self, index) -> int
Returns: The indicated integer 

Arguments:
	[in]	index = int


Extract the indicated integer from the const instance. No checking is done by this class to ensure that the index is valid - use the length method to determine the size of the array. If the instance is not attached to an  MObject , this method will return an integer containing zero.'''
        pass

    def create(self, arr): 
        '''create(self, arr) -> MObject
Returns: The newly created MObject 

Arguments:
	[in]	arr = MIntArray


Create a new  MObject , attach it to this instance, and initialize it to contain the data from the given  MIntArray .'''
        pass

    def copyTo(self, dest): 
        '''copyTo(self, dest)
Arguments:
	[out]	dest = MIntArray


Copy all the integers in the instance into the given  MIntArray .'''
        pass

    def className(self): 
        '''className(self) -> char*

'''
        pass

    def length(self): 
        '''length(self) -> int
Returns: The number of integers in the instance 


Return the number of integers in the instance.'''
        pass

    def array(self): 
        '''array(self) -> MIntArray
Returns: A copy of the MIntArray held in this instance 


Return an  MIntArray  containing the integer array currently operated upon by the function set. The  MIntArray  returned by this method is editable, so any changes to the return instance also affects the  MObject  operated upon by this function set.'''
        pass

    def type(self): 
        '''type(self) -> MFn.Type

'''
        pass

class MFnLambertShader:
    '''Manage Lambert shaders. MFnLambertShader facilitates creation and manipulation of dependency graph nodes representing lambertian shaders. '''
    def __init__(self):
        pass


    def color(self): 
        '''color(self) -> MColor
Returns: The value of the "color" attribute of the shader node.


Retrieves the value of the "color" attribute of a shader node. This attribute represents the surface color of the shader.'''
        pass

    def glowIntensity(self): 
        '''glowIntensity(self) -> float
Returns: The value of the "glowIntensity" attribute of the shader node.


Retrieves the value of the "glowIntensity" attribute of a shader node. This attribute represents the constant multplier applied to the glow color of the shader.'''
        pass

    def refractiveIndex(self): 
        '''refractiveIndex(self) -> float
Returns: The value of the "refractiveIndex" attribute of the shader node.


Retrieves the value of the "refractiveIndex" attribute of a lambert shader node. This attribute represents the refractive index of the shader.'''
        pass

    def setAmbientColor(self, ambient_color): 
        '''setAmbientColor(self, ambient_color)
Arguments:
	[in]	ambient_color = MColor


Sets the value of the "ambientColor" attribute of a shader node.'''
        pass

    def diffuseCoeff(self): 
        '''diffuseCoeff(self) -> float
Returns: The value of the "diffuseCoeff" attribute of the shader node.


Retrieves the value of the "diffuseCoeff" attribute of a lambert shader node. This attribute represents the diffuse reflectivity of the shader.'''
        pass

    def setHideSource(self, hide_source): 
        '''setHideSource(self, hide_source)
Arguments:
	[in]	hide_source = bool


Sets the value of the "hideSource" attribute of a shader node.'''
        pass

    def create(self, UIvisible): 
        '''create(self, UIvisible) -> MObject
Returns: MObject representing the new dependency node.

Arguments:
	[in]	UIvisible = bool


Creates a new lambert shader dependency graph node and adds it to the dependency graph. If the UIvisible parameter is true, the new node will be connected to the shader classification node (which allows the UI to recognize the node as a shader). If UIvisible is false, the node will be created in isolation.'''
        pass

    def setRefractiveIndex(self, refractive_index): 
        '''setRefractiveIndex(self, refractive_index)
Arguments:
	[in]	refractive_index = float


Sets the value of the "refractiveIndex" attribute of a shader node.'''
        pass

    def refractedRayDepthLimit(self): 
        '''refractedRayDepthLimit(self) -> short
Returns: The value of the "refractedRayDepthLimit" attribute of the node.


Retrieves the value of the "refractedRayDepthLimit" attribute of a lambert shader node. This attribute represents the maximum refracted ray depth used in the shading calculation.'''
        pass

    def setGlowIntensity(self, glow_intensity): 
        '''setGlowIntensity(self, glow_intensity)
Arguments:
	[in]	glow_intensity = float


Sets the value of the "glowIntensity" attribute of a shader node.'''
        pass

    def setDiffuseCoeff(self, diffuse_coeff): 
        '''setDiffuseCoeff(self, diffuse_coeff)
Arguments:
	[in]	diffuse_coeff = float


Sets the value of the "diffuseCoeff" attribute of a shader node.'''
        pass

    def type(self): 
        '''type(self) -> MFn.Type

'''
        pass

    def setIncandescence(self, incand): 
        '''setIncandescence(self, incand)
Arguments:
	[in]	incand = MColor


Sets the value of the "incandescence" attribute of a shader node.'''
        pass

    def incandescence(self): 
        '''incandescence(self) -> MColor
Returns: The value of the "incandescence" attribute of the shader node.


Retrieves the value of the "incandescence" attribute of a shader node. This attribute represents the incandescence of the shader.'''
        pass

    def setTransparency(self, transp): 
        '''setTransparency(self, transp)
Arguments:
	[in]	transp = MColor


Sets the value of the "transparency" attribute of a shader node.'''
        pass

    def setRtRefractedColor(self, rt_refracted_color): 
        '''setRtRefractedColor(self, rt_refracted_color)
Arguments:
	[in]	rt_refracted_color = bool


Sets the value of the "rtRefractedColor" attribute of a shader node.'''
        pass

    def translucenceCoeff(self): 
        '''translucenceCoeff(self) -> float
Returns: The value of the "translucenceCoeff" attribute of the shader node.


Retrieves the value of the "translucenceCoeff" attribute of a lambert shader node. This attribute represents a constant multiplier applied to the transparency attribute of the shader.'''
        pass

    def setRefractedRayDepthLimit(self, refracted_ray_depth_limit): 
        '''setRefractedRayDepthLimit(self, refracted_ray_depth_limit)
Arguments:
	[in]	refracted_ray_depth_limit = short


Sets the value of the "refractedRayDepthLimit" attribute of a lambert shader node.'''
        pass

    def setColor(self, col): 
        '''setColor(self, col)
Arguments:
	[in]	col = MColor


Sets the value of the "color" attribute of a shader node.'''
        pass

    def className(self): 
        '''className(self) -> char*

'''
        pass

    def ambientColor(self): 
        '''ambientColor(self) -> MColor
Returns: The value of the "ambientColor" attribute of the shader node.


Retrieves the value of the "ambientColor" attribute of a shader node. This attribute represents the ambient color of the shader.'''
        pass

    def transparency(self): 
        '''transparency(self) -> MColor
Returns: The value of the "transparency" attribute of the shader node.


Retrieves the value of the "transparency" attribute of a shader node. This attribute represents the surface transparency of the shader.'''
        pass

    def rtRefractedColor(self): 
        '''rtRefractedColor(self) -> bool
Returns: The value of the "rtRefractedColor" attribute of the shader node.


Retrieves the value of the "rtRefractedColor" attribute of a shader node. This attribute determines whether the shader uses the value of the "refractedColor" attribute for the refracted color or calculated the refracted color itself.'''
        pass

    def hideSource(self): 
        '''hideSource(self) -> bool
Returns: The value of the "hideSource" attribute of the shader node.


Retrieves the value of the "hideSource" attribute of a shader node. This attribute determines whether or not the computed surface color is used in the shading computation. If hideSource is true, then only the computed shader glow color will be used. Otherwise, both the glow and surface colors will be used.'''
        pass

    def setTranslucenceCoeff(self, translucence_coeff): 
        '''setTranslucenceCoeff(self, translucence_coeff)
Arguments:
	[in]	translucence_coeff = float


Sets the value of the "translucenceCoeff" attribute of a shader node.'''
        pass

class MFnLatticeData:
    '''Lattice Data dependency graph type. This simple function set is used to create lattice data objects that can be transmitted through the dependency graph. It can also be used to extract the lattice geometry from the data object.See MDataHandle and MDataBlock for more information about getting and setting data in the dependency graph. '''
    def __init__(self):
        pass


    def className(self): 
        '''className(self) -> char*

'''
        pass

    def lattice(self): 
        '''lattice(self) -> MObject
Returns: A handle to the new lattice data object


Returns the lattice geometry so that it may be modified using the  MFnLattice  function set.'''
        pass

    def create(self): 
        '''create(self) -> MObject
Returns: A handle to the new lattice data object


This method create a new lattice data object for use with the dependency graph. A node's lattice attribute may be set with this object using  MDataHandle .'''
        pass

    def type(self): 
        '''type(self) -> MFn.Type

'''
        pass

class MFnLayeredShader:
    '''Manage Layered shaders. MFnLayeredShader facilitates creation and manipulation of dependency graph nodes representing layered shaders. '''
    def __init__(self):
        pass


    def setGlowColor(self, glow_color, lIndex): 
        '''setGlowColor(self, glow_color, lIndex)
Arguments:
	[in]	glow_color = MColor
	[in]	lIndex = int


Sets the value of the "glowColor" attribute of a shader node.'''
        pass

    def setHardwareShader(self, hardware_shader): 
        '''setHardwareShader(self, hardware_shader)
Arguments:
	[in]	hardware_shader = MColor


Sets the value of the "hardwareShader" attribute of a shader node.'''
        pass

    def compositingFlag(self): 
        '''compositingFlag(self) -> short
Returns: The value of the "compositingFlag" attribute of the shader node.


Retrieves the value of the "compositingFlag" attribute of a shader node.'''
        pass

    def color(self, lIndex): 
        '''color(self, lIndex) -> MColor

Arguments:
	[in]	lIndex = int


Retrieves the value of the "color" attribute of a shader node. This attribute represents the surface color of the shader.'''
        pass

    def create(self, UIvisible): 
        '''create(self, UIvisible) -> MObject
Returns: MObject representing the new dependency node.

Arguments:
	[in]	UIvisible = bool


Creates a new layered shader dependency graph node and adds it to the dependency graph. If the UIvisible parameter is true, the new node will be connected to the shader classification node (which allows the UI to recognize the node as a shader). If UIvisible is false, the node will be created in isolation.'''
        pass

    def glowColor(self, lIndex): 
        '''glowColor(self, lIndex) -> MColor

Arguments:
	[in]	lIndex = int


Retrieves the value of the "glowColor" attribute of a shader node. This attribute represents the ambient color of the shader.'''
        pass

    def className(self): 
        '''className(self) -> char*

'''
        pass

    def hardwareColor(self): 
        '''hardwareColor(self) -> MColor
Returns: The value of the "hardwareColor" attribute of the shader node.


Retrieves the value of the "hardwareColor" attribute of a shader node. This attribute represents the color of the material that appears in shaded mode.'''
        pass

    def setTransparency(self, transp, lIndex): 
        '''setTransparency(self, transp, lIndex)
Arguments:
	[in]	transp = MColor
	[in]	lIndex = int


Sets the value of the "transparency" attribute of a shader node.'''
        pass

    def transparency(self, lIndex): 
        '''transparency(self, lIndex) -> MColor

Arguments:
	[in]	lIndex = int


Retrieves the value of the "transparency" attribute of a shader node. This attribute represents the surface transparency of the shader.'''
        pass

    def setCompositingFlag(self, cflag): 
        '''setCompositingFlag(self, cflag)
Arguments:
	[in]	cflag = short


Sets the value of the "compositingFlag" attribute of a shader node.'''
        pass

    def setHardwareColor(self, hardware_color): 
        '''setHardwareColor(self, hardware_color)
Arguments:
	[in]	hardware_color = MColor


Sets the value of the "hardwareColor" attribute of a shader node.'''
        pass

    def type(self): 
        '''type(self) -> MFn.Type

'''
        pass

    def hardwareShader(self): 
        '''hardwareShader(self) -> MColor
Returns: The value of the "hardwareShader" attribute of the shader node.


Retrieves the value of the "hardwareShader" attribute of a layered shader node.'''
        pass

    def setColor(self, col, lIndex): 
        '''setColor(self, col, lIndex)
Arguments:
	[in]	col = MColor
	[in]	lIndex = int


Sets the value of the "color" attribute of a shader node.'''
        pass

class MFnLight:
    '''Manage dependency graph nodes representing lights. MFnLight allows the creation and manipulation of dependency graph nodes representing lights. This is the top level of a hierarchy of light node function sets. It permits manipulation of the attributes common to all types of lights. '''
    def __init__(self):
        pass


    def rayDepthLimit(self): 
        '''rayDepthLimit(self) -> short
Returns: The value of the "rayDepthLimit" attribute of the light node.


Retrieves the value of the "rayDepthLimit" attribute of a light node. This attribute determines a cutoff point for shadow calculations related to the light. Rays whose depth is higher than the value of this attribute will not trigger a shadow calculation for the light.'''
        pass

    def useRayTraceShadows(self): 
        '''useRayTraceShadows(self) -> bool
Returns: The value of the "useRayTraceShadows" attribute of the light node.


Retrieves the value of the "useRayTraceShadows" attribute of a light node. This attribute determines whether or not the light should raytrace it's shadows.'''
        pass

    def color(self): 
        '''color(self) -> MColor
Returns: The value of the "color" attribute of the light node.


Retrieves the value of the "color" attribute of a light node. This attribute represents the color of the light emitted by the light node.'''
        pass

    def numShadowSamples(self): 
        '''numShadowSamples(self) -> short
Returns: The value of the "numShadowSamples" attribute of the light node.


Retrieves the value of the "numShadowSamples" attribute of a light node. This attribute represents the number of shadow samples per point used in occulusion testing.'''
        pass

    def intensity(self): 
        '''intensity(self) -> float
Returns: The value of the "intensity" attribute of the light node.


Retrieves the value of the "intensity" attribute of a light node. This attribute represents a uniform scaling factor applied to the light color.'''
        pass

    def setUseRayTraceShadows(self, useRayTraceShadows): 
        '''setUseRayTraceShadows(self, useRayTraceShadows)
Arguments:
	[in]	useRayTraceShadows = bool


Sets the value of the "useRayTraceShadows" attribute of a light node.'''
        pass

    def lightAmbient(self): 
        '''lightAmbient(self) -> bool
Returns: The value of the "lightAmbient" attribute of the light node.


Retrieves the value of the "lightAmbient" attribute of a light node. This attribute indicates if the light has an ambient component.'''
        pass

    def opticalFXvisibility(self): 
        '''opticalFXvisibility(self) -> MColor
Returns: The value of the "opticalFXvisibility" attribute of the light node.


Retrieves the value of the "opticalFXvisibility" attribute of a light node. This attribute represents an occlusion scaling factor for light glow effects on this light.'''
        pass

    def setOpticalFXvisibility(self, visibility): 
        '''setOpticalFXvisibility(self, visibility)
Arguments:
	[in]	visibility = MColor


Sets the value of the "opticalFXvisibility" attribute of a light node.'''
        pass

    def shadowColor(self): 
        '''shadowColor(self) -> MColor
Returns: The value of the "shadowColor" attribute of the light node.


Retrieves the value of the "shadowColor" attribute of a light node. This attribute represents the color of the shadows cast by the light.'''
        pass

    def type(self): 
        '''type(self) -> MFn.Type

'''
        pass

    def setCenterOfIllumination(self, dist): 
        '''setCenterOfIllumination(self, dist)
Arguments:
	[in]	dist = double


Sets the value of the "centerOfIllumination" attribute of a light node.'''
        pass

    def setNumShadowSamples(self, num_shadow_samples): 
        '''setNumShadowSamples(self, num_shadow_samples)
Arguments:
	[in]	num_shadow_samples = short


Sets the value of the "numShadowSamples" attribute of a light node.'''
        pass

    def setShadowColor(self, shadow_color): 
        '''setShadowColor(self, shadow_color)
Arguments:
	[in]	shadow_color = MColor


Sets the value of the "shadowColor" attribute of a light node.'''
        pass

    def lightDirection(self): 
        '''lightDirection(self) -> MFloatVector
Returns: The value of the "lightDirection" attribute of the light node.


Retrieves the value of the "lightDirection" attribute of a light node. This attribute represents the direction from the light to the point being shading.'''
        pass

    def setColor(self, col): 
        '''setColor(self, col)
Arguments:
	[in]	col = MColor


Sets the value of the "color" attribute of a light node.'''
        pass

    def lightDiffuse(self): 
        '''lightDiffuse(self) -> bool
Returns: The value of the "lightDiffuse" attribute of the light node.


Retrieves the value of the "lightDiffuse" attribute of a light node. This attribute indicates if the light has a diffuse component.'''
        pass

    def centerOfIllumination(self): 
        '''centerOfIllumination(self) -> double
Returns: The value of the "centerOfIllumination" attribute of the light node.


Retrieves the value of the "centerOfIllumination" attribute of a light node. This attribute represents the distance to the center of illumination of the light.'''
        pass

    def className(self): 
        '''className(self) -> char*

'''
        pass

    def lightSpecular(self): 
        '''lightSpecular(self) -> bool
Returns: The value of the "lightSpecular" attribute of the light node.


Retrieves the value of the "lightSpecular" attribute of a light node. This attribute indicates if the light has a specular component.'''
        pass

    def setIntensity(self, intens): 
        '''setIntensity(self, intens)
Arguments:
	[in]	intens = float


Sets the value of the "intensity" attribute of a light node.'''
        pass

    def setRayDepthLimit(self, ray_depth_limit): 
        '''setRayDepthLimit(self, ray_depth_limit)
Arguments:
	[in]	ray_depth_limit = short


Sets the value of the "rayDepthLimit" attribute of a light node.'''
        pass

    def lightIntensity(self): 
        '''lightIntensity(self) -> MColor
Returns: The value of the "lightIntensity" attribute of the light node.


Retrieves the value of the "lightIntensity" attribute of a light node. This attribute represents the intensity of the light specified as a color.'''
        pass

class MFnLightDataAttribute:
    '''Light data attribute function set. Function object for LightData attributes. A LightData attribute describes a single light source, giving its direction and intensity, as well as specifying whether or not it contributes to the ambient, diffuse, and specular components of the shading model. '''
    def __init__(self):
        pass


    def setDefault(self, defDirectionX, defDirectionY, defDirectionZ, defIntensityR, defIntensityG, defIntensityB, defAmbient, defDiffuse, defSpecular, defShadowFraction, defPreShadowIntensity, defBlindData): 
        '''setDefault(self, defDirectionX, defDirectionY, defDirectionZ, defIntensityR, defIntensityG, defIntensityB, defAmbient, defDiffuse, defSpecular, defShadowFraction, defPreShadowIntensity, defBlindData)
Arguments:
	[in]	defDirectionX = float
	[in]	defDirectionY = float
	[in]	defDirectionZ = float
	[in]	defIntensityR = float
	[in]	defIntensityG = float
	[in]	defIntensityB = float
	[in]	defAmbient = bool
	[in]	defDiffuse = bool
	[in]	defSpecular = bool
	[in]	defShadowFraction = float
	[in]	defPreShadowIntensity = float
	[in]	defBlindData = void


Sets the default value for the attribute.'''
        pass

    def create(self, fullName, briefName, direction, intensity, ambient, diffuse, specular, shadowFraction, preShadowIntensity, blindData): 
        '''create(self, fullName, briefName, direction, intensity, ambient, diffuse, specular, shadowFraction, preShadowIntensity, blindData) -> MObject

Arguments:
	[in]	fullName = MString
	[in]	briefName = MString
	[in]	direction = MObject
	[in]	intensity = MObject
	[in]	ambient = MObject
	[in]	diffuse = MObject
	[in]	specular = MObject
	[in]	shadowFraction = MObject
	[in]	preShadowIntensity = MObject
	[in]	blindData = MObject


Creates a LightData attribute object.'''
        pass

    def className(self): 
        '''className(self) -> char*

'''
        pass

    def getDefault(self, defDirectionX, defDirectionY, defDirectionZ, defIntensityR, defIntensityG, defIntensityB, defAmbient, defDiffuse, defSpecular, defShadowFraction, defPreShadowIntensity, defBlindData): 
        '''getDefault(self, defDirectionX, defDirectionY, defDirectionZ, defIntensityR, defIntensityG, defIntensityB, defAmbient, defDiffuse, defSpecular, defShadowFraction, defPreShadowIntensity, defBlindData)
Arguments:
	[out]	defDirectionX = float
	[out]	defDirectionY = float
	[out]	defDirectionZ = float
	[out]	defIntensityR = float
	[out]	defIntensityG = float
	[out]	defIntensityB = float
	[out]	defAmbient = bool
	[out]	defDiffuse = bool
	[out]	defSpecular = bool
	[out]	defShadowFraction = float
	[out]	defPreShadowIntensity = float
	[out]	defBlindData = void


Gets the default value for the attribute.'''
        pass

    def child(self, index): 
        '''child(self, index) -> MObject
Returns: A pointer to the desired child attribute

Arguments:
	[in]	index = int


Gets a pointer to one of the child attributes.'''
        pass

    def type(self): 
        '''type(self) -> MFn.Type

'''
        pass

class MFnMatrixAttribute:
    '''Matrix attribute function set. Function object for matrix attributes. These attributes accept either a matrix of float values or double values depending on the type specified to the create method. '''
    def __init__(self):
        pass


    def setDefault(self, defaultArg): 
        '''setDefault(self, defaultArg)
Arguments:
	[in]	defaultArg = MFloatMatrix


Sets the default value for the attribute. Use this for setting the defaults of a float matrix attribute.'''
        pass

    def kDouble(self):
        '''This is an enum of Type.
Description: Matrix of double values.
Value: 1'''
        pass

    def kFloat(self):
        '''This is an enum of Type.
Description: Matrix of float values.
Value: 0'''
        pass

    class Type:
        '''Non-functional class.  Values for this enum:
        kDouble
        kFloat
'''
        def __init__(self):
            pass

    def create(self, fullName, briefName, matrixType): 
        '''create(self, fullName, briefName, matrixType) -> MObject
Returns: The newly created Matrix attribute object.

Arguments:
	[in]	fullName = MString
	[in]	briefName = MString
	[in]	matrixType = MFnMatrixAttribute.Type


Creates a matrix attribute object.'''
        pass

    def className(self): 
        '''className(self) -> char*

'''
        pass

    def getDefault(self, defaultArg): 
        '''getDefault(self, defaultArg)
Arguments:
	[out]	defaultArg = MFloatMatrix


Gets the default value for the attribute. Use this for getting the default value of a float matrix attribute.'''
        pass

    def type(self): 
        '''type(self) -> MFn.Type

'''
        pass

class MFnMatrixData:
    '''Matrix function set for dependency node data. MFnMatrixData allows the creation and manipulation of MMatrix data objects for use in the dependency graph.If a user written dependency node either accepts or produces MMatrix, then this class is used to extract or create the data that comes from or goes to other dependency graph nodes. The MDataHandle::type method will return kMatrix when data of this type is present. To access it, the MDataHandle::data method is used to get an MObject for the data and this should then be used to initialize an instance of MFnMatrixData. '''
    def __init__(self):
        pass


    def set(self, mat): 
        '''set(self, mat)
Arguments:
	[in]	mat = MMatrix


Set this instance to hold a copy of the given matrix.'''
        pass

    def MMatrix(self): 
        '''MMatrix(self) -> const
Returns: A const reference to the MMatrix 


Return a constant reference to the matrix held in this instance.'''
        pass

    def create(self, transformation): 
        '''create(self, transformation) -> MObject
Returns: The new MObject 

Arguments:
	[in]	transformation = MTransformationMatrix


Create a new  MObject , attach it to this instance and initialize it to the given transform matrix.'''
        pass

    def isTransformation(self): 
        '''isTransformation(self) -> bool
Returns: true if the instance holds a transform matrix, false otherwise 


Determine if the matrix held in this instance is a transform matrix.'''
        pass

    def className(self): 
        '''className(self) -> char*

'''
        pass

    def type(self): 
        '''type(self) -> MFn.Type

'''
        pass

    def transformation(self): 
        '''transformation(self) -> MTransformationMatrix
Returns: A copy of the MTransformationMatrix held in this instance 


Return a copy of the transform matrix held in this instance.'''
        pass

class MFnMesh:
    '''Polygonal surface function set.  The following terms are used interchangeably: - they range between 0..(numVertices()-1) - they range between 0..(polygonVertexCount(faceId)-1)This function set provides access to polygonal meshes. Objects of type MFn::kMesh, MFn::kMeshData, and MFn::kMeshGeom are supported. MFn::kMesh objects are shapes in the DAG, MFn::kMeshGeom objects are the raw geometry that the shapes use, and MFn::kMeshData objects are the data that is passed through dependency graph connections.NOTE: If the function set has been initialized with a MFn::kMesh object then it must have geometry attached. Meshes are created by specifying a vertex list, a list of vertex counts per-polygon, and a list of vertices that make up the polygons. Edge data is also maintained for the mesh and can be returned to the caller. The following lists are used by the create method to construct a mesh:There are several cases in which the create method will alter the data passed in:use the appropriate vertices. You can optionally specify texture (uv) coordinates. UV coordinates are 2-d coordinates used for mapping textures to the polygons of a mesh. All of the uv coordinates are stored in one or more named UV sets. The default mesh uv list stores uv coordinates in an array indexed from 0 to numUVs()-1. UV's are referenced on a per-polygon per-vertex basis, so for a polygon with 4 vertices there would be 4 uv's. The uv values for a polygon are set by specifying the index of the uv for each vertex of the polygon. This index is the uv's position in the master uv array. UV's are optional so polygons do not have to have uv values associated with them. There may be only 1 or 2 polygons in a mesh that have uv coordinates set, or all of the polygons may have uv's. UV's can also be shared so several different polygons may reference the same uv's. If you are creating a UV for the first time or changing the order of the UV then you need to set the UV using one of the setUV methods and then assign new indices using one of the assignUV methods. It is not necessary to call assignUV if editing the position of an existing UV. You can optionally specify color per vertex information using this class. It is possible to create and manipulate color per vertex information using the methods available. Many of the color per vertex methods have a default parameter: colorSet. If unspecified, the method will operate on the current color set. Some of the Normals in Maya are now user-settable. If the vertex normals are not set or locked, they are computed by maya when the mesh changes. If set or locked, the normals remain frozen relative to the object, unless the user unlocks them. There are 3 types of normals for a mesh:For a cube, the list would contain 24 normals (4 vertices * 6 polygons) since the edges for a cube are hard and the per-vertex per-polygon normals cannot be shared. For a sphere or torus, which has smooth edges, the normals can be shared, and thus the normal list contains the same number of normals as vertices. MFnMesh allows you to create Blind Data types, and to create and access mesh component level blind data, but not object level blind data. Object level data may be assigned through the polyBlindData command or the Blind Data Editor. However, object level blind data is just an ordinary compound dynamic attribute directly on the object. The parent attribute name is BlindDataNNNN where NNNN is the blind data typeID. e.g. if your typeId is 1001 your object will have a compound dynamic attr called BlindData1001. There are also three iterator classes which provide more specific control over the vertices, edges, and polygons of a mesh and are useful when dealing with components. See MItMeshPolygon, MItMeshEdge, and MItMeshVertex. '''
    def __init__(self):
        pass


    def setCurrentUVSetName(self, setName, modifier, currentSelection): 
        '''setCurrentUVSetName(self, setName, modifier, currentSelection)
Arguments:
	[in]	setName = MString
	[in]	modifier = MDGModifier
	[in]	currentSelection = MSelectionList


Set the "current" uv set for this object. The "current" uv set is the uv set to use when no uv set name is specified for a uv set operation. If the uv set does not exist then the "current" uv set will not be changed.'''
        pass

    def getBinaryBlindData(self, compType, blindDataId, attrName, compIDs, data): 
        '''getBinaryBlindData(self, compType, blindDataId, attrName, compIDs, data)
Arguments:
	[in]	compType = MFn.Type
	[in]	blindDataId = int
	[in]	attrName = MString
	[out]	compIDs = MIntArray
	[out]	data = MStringArray


Get the blind data value for the specified blind data attribute for all components of the given type. If the type of the attribute is not correct, this method will fail.'''
        pass

    def onBoundary(self, polygonId): 
        '''onBoundary(self, polygonId) -> bool
Returns: true If the specified edge is on the border of the object. 
false If the specified edge is not on the boundary of the object.

Arguments:
	[in]	polygonId = int


A method to determines whether the specified face in the mesh is a boundary face.'''
        pass

    def setVertexColors(self, colors, vertexList, modifier, rep): 
        '''setVertexColors(self, colors, vertexList, modifier, rep)
Arguments:
	[in]	colors = MColorArray
	[in]	vertexList = MIntArray
	[in]	modifier = MDGModifier
	[in]	rep = MFnMesh.MColorRepresentation


Set color of specified channels for these vertices.'''
        pass

    def copyInPlace(self, source): 
        '''copyInPlace(self, source)
Arguments:
	[in]	source = MObject


This method creates copies the given source mesh onto the current surface. After the copy this function set continues operate on the original mesh.'''
        pass

    def isColorClamped(self, colorSet): 
        '''isColorClamped(self, colorSet) -> bool
Returns: true All components in the color set are clamped 
false All components in the color set are not clamped

Arguments:
	[in]	colorSet = MString


This method returns if the color set has its R,G,B,and A components clamped in the range from 0 to 1.'''
        pass

    def getTangents(self, space, uvSet, tangents): 
        '''getTangents(self, space, uvSet, tangents)
Arguments:
	[out]	tangents = MFloatVectorArray
	[in]	space = MSpace.Space
	[in]	uvSet = MString


Return the tangent vectors for all face vertices. The tangent is defined as the surface tangent of the polygon running in the U direction defined by the uv map.'''
        pass

    def unlockVertexNormals(self, vertexList): 
        '''unlockVertexNormals(self, vertexList)
Arguments:
	[in]	vertexList = MIntArray


Unlock Shared Normals for these vertices'''
        pass

    def getUVSetFamilyNames(self, familyNames): 
        '''getUVSetFamilyNames(self, familyNames)
Arguments:
	[out]	familyNames = MStringArray


Get the names of all of the uv set families on this object. A uv set family is a set of per-instance sets with the same name with each individual set applying to one or more instances. A set which is shared across all instances will be the sole member of its family.'''
        pass

    def setCreaseVertices(self, vertexIds, creaseData): 
        '''setCreaseVertices(self, vertexIds, creaseData)
Arguments:
	[in]	vertexIds = MUintArray
	[in]	creaseData = MDoubleArray


This method sets the specified vertices of the mesh as crease vertices.'''
        pass

    def numVertices(self): 
        '''numVertices(self) -> int
Returns: The number of vertices of the mesh


Returns the number of vertices in the vertex list for this mesh. This number will be the same as the length of the vertex array returned with the getPoints method.'''
        pass

    def setCheckSamePointTwice(self, check): 
        '''setCheckSamePointTwice(self, check)
Arguments:
	[in]	check = bool


This method allows the turning on or off of duplicate point checking when polygons are created or added using this class. Checking for duplicates, is the default state.'''
        pass

    def getFaceVertexColorIndex(self, faceIndex, localVertexIndex, colorSet, colorIndex): 
        '''getFaceVertexColorIndex(self, faceIndex, localVertexIndex, colorSet, colorIndex)
Arguments:
	[in]	faceIndex = int
	[in]	localVertexIndex = int
	[out]	colorIndex = int
	[in]	colorSet = MString


Get an index into the array returned by getFaceVertexColors. So that you can index into the array directly, instead of walking it in face-vertex order.'''
        pass

    def getVertices(self, vertexCount, vertexList): 
        '''getVertices(self, vertexCount, vertexList)
Arguments:
	[out]	vertexCount = MIntArray
	[out]	vertexList = MIntArray


This method retrieves the  object-relative (mesh-relative/global)  vertex indices for all polygons. The indices refer to the elements in the array returned by the 'getPoints' method.'''
        pass

    def currentUVSetName(self, instance): 
        '''currentUVSetName(self, instance) -> MString
Returns: UV set name.

Arguments:
	[in]	instance = int


Get the name of the "current" uv set. The "current" uv set is the uv set which is used for uv operations when no uv set is explicitly specified.'''
        pass

    def getPolygonVertices(self, polygonId, vertexList): 
        '''getPolygonVertices(self, polygonId, vertexList)
Arguments:
	[in]	polygonId = int
	[out]	vertexList = MIntArray


This method retrieves the  object-relative (mesh-relative/global)  vertex indices for the specified polygon. The indices refer to the elements in the array returned by the 'getPoints' method.'''
        pass

    def addPolygon(self, vertexArray, mergeVertices, pointTolerance, parentOrOwner, faceIndex): 
        '''addPolygon(self, vertexArray, mergeVertices, pointTolerance, parentOrOwner, faceIndex) -> MObject
Returns: The transform if one is created, otherwise the geometry.

Arguments:
	[in]	vertexArray = MPointArray
	[out]	faceIndex = int
	[in]	mergeVertices = bool
	[in]	pointTolerance = double
	[in]	parentOrOwner = MObject


Adds a new polygon to this polygonal mesh. Return an index of the created polygon.'''
        pass

    def collapseEdges(self, edgeList): 
        '''collapseEdges(self, edgeList)
Arguments:
	[in]	edgeList = MIntArray


This function collapse edges into vertices. The two vertices that create each given edge are replaced in turn by one vertex placed at the average of the two initial vertex.'''
        pass

    def getEdgeVertices(self, edgeId, vertexList): 
        '''getEdgeVertices(self, edgeId, vertexList)
Arguments:
	[in]	edgeId = int
	[out]	vertexList = int2


This method retrieves the  object-relative (mesh-relative/global)  vertex indices corresponding to the specified edge. The indices can be used to refer to the elements in the array returned by the 'getPoints' method.'''
        pass

    def getAssociatedUVSetTextures(self, uvSetName, textures): 
        '''getAssociatedUVSetTextures(self, uvSetName, textures)
Arguments:
	[in]	uvSetName = MString
	[out]	textures = MObjectArray


Get a list of texture nodes which are using a given uv set. If the texture has a 2d texture placement, the texture, and not the placement will be returned.'''
        pass

    def copyUVSetWithName(self, fromName, toName, modifier): 
        '''copyUVSetWithName(self, fromName, toName, modifier) -> MString
Returns: The name of the new UV set. May be different then the name passed in if a new name was generated.

Arguments:
	[in]	fromName = MString
	[in]	toName = MString
	[in]	modifier = MDGModifier


Copies a uv set from one to another for this mesh. The source must exist. The following cases can occur:'''
        pass

    def getFaceVertexBlindDataIndex(self, faceIndex, vertexIndex, blindDataIndex): 
        '''getFaceVertexBlindDataIndex(self, faceIndex, vertexIndex, blindDataIndex)
Arguments:
	[in]	faceIndex = int
	[in]	vertexIndex = int
	[out]	blindDataIndex = int


Get the single index to retrieve face-vertex blind data.'''
        pass

    def cachedIntersectionAcceleratorInfo(self): 
        '''cachedIntersectionAcceleratorInfo(self) -> MString


Retrieves a string that describes the intersection acceleration structure for this object, if any. The string is formatted similar to:'''
        pass

    def getConnectedShaders(self, instanceNumber, shaders, indices): 
        '''getConnectedShaders(self, instanceNumber, shaders, indices)
Arguments:
	[in]	instanceNumber = int
	[out]	shaders = MObjectArray
	[out]	indices = MIntArray


Returns all the shaders (sets) connected to the specified instance of this mesh. As well as an array of polygon/shader assignments. The indices array will hold for each polygon in the mesh, an index into the shaders array. If a polygon does not have a shader assigned to it, the value of the index will be -1.'''
        pass

    def getBlindDataAttrNames(self, blindDataId, longNames, shortNames): 
        '''getBlindDataAttrNames(self, blindDataId, longNames, shortNames)
Arguments:
	[in]	blindDataId = int
	[out]	longNames = MStringArray
	[out]	shortNames = MStringArray


Get the blind data attribute names for the specified blind data type id.'''
        pass

    def numUVSets(self): 
        '''numUVSets(self) -> int
Returns: The number of uv sets for the object


Returns the number of uv sets for an object.'''
        pass

    def getFaceNormalIds(self, faceIndex, normals): 
        '''getFaceNormalIds(self, faceIndex, normals)
Arguments:
	[in]	faceIndex = int
	[out]	normals = MIntArray


Return normal indices for all vertices for a given face. The normalIds can be used to index into an array returned by  MFnMesh::getNormals() ;'''
        pass

    def getColor(self, colorId, colorSet, defaultUnsetColor, color): 
        '''getColor(self, colorId, colorSet, defaultUnsetColor, color)
Arguments:
	[in]	colorId = int
	[out]	color = MColor
	[in]	colorSet = MString
	[in]	defaultUnsetColor = MColor


Get the value of the specified texture coordinate from this mesh's color list. The colorId is the element in the color list that will be retrieved. If the color is not set, defaultUnsetColor will be return. If defaultUnsetColor is not set, (0,0,0,1) will be return.'''
        pass

    def getVertexNormals(self, angleWeighted, space, normals): 
        '''getVertexNormals(self, angleWeighted, space, normals)
Arguments:
	[in]	angleWeighted = bool
	[out]	normals = MFloatVectorArray
	[in]	space = MSpace.Space


Return all vertex normals. The returned normals are per-vertex normals, so unshared normals at a vertex will be averaged. See the class description for more information on normals.'''
        pass

    def numColors(self, colorSet): 
        '''numColors(self, colorSet) -> int
Returns: The number of colors

Arguments:
	[in]	colorSet = MString


Returns the number of colors (vertex data) for this mesh. The colors are stored in a list which is referenced by polygons requiring textures on a per-polygon per-vertex basis. This method returns the number of elements in this list.'''
        pass

    def getPoint(self, vertexId, space, pos): 
        '''getPoint(self, vertexId, space, pos)
Arguments:
	[in]	vertexId = int
	[out]	pos = MPoint
	[in]	space = MSpace.Space


Get the position of the specified vertex in this mesh's vertex list.'''
        pass

    def assignColor(self, polygonId, vertexIndex, colorId, colorSet): 
        '''assignColor(self, polygonId, vertexIndex, colorId, colorSet)
Arguments:
	[in]	polygonId = int
	[in]	vertexIndex = int
	[in]	colorId = int
	[in]	colorSet = MString


Maps a color value to a specified vertex of a polygon.'''
        pass

    def binaryBlindDataComponentId(self, compID, compType, blindDataId, attrName): 
        '''binaryBlindDataComponentId(self, compID, compType, blindDataId, attrName) -> MString
Returns: The data item.

Arguments:
	[in]	compID = int
	[in]	compType = MFn.Type
	[in]	blindDataId = int
	[in]	attrName = MString


Get the blind data value for the specified blind data attribute of the specified component. If the type of the attribute is not correct, this method will fail.'''
        pass

    def setNormals(self, normals, space): 
        '''setNormals(self, normals, space)
Arguments:
	[in]	normals = MFloatVectorArray
	[in]	space = MSpace.Space


Set the normal array (user normals)'''
        pass

    def clearBlindData(self, compType, blindDataId): 
        '''clearBlindData(self, compType, blindDataId)
Arguments:
	[in]	compType = MFn.Type
	[in]	blindDataId = int


Delete the values for a binary blind data type (all its attributes) from all components of the given type.'''
        pass

    def getStringBlindData(self, compType, blindDataId, attrName, compIDs, data): 
        '''getStringBlindData(self, compType, blindDataId, attrName, compIDs, data)
Arguments:
	[in]	compType = MFn.Type
	[in]	blindDataId = int
	[in]	attrName = MString
	[out]	compIDs = MIntArray
	[out]	data = MStringArray


Get the blind data value for the specified blind data attribute for all components of the given type. If the type of the attribute is not correct, this method will fail.'''
        pass

    def booleanOp(self, op, mesh1, mesh2): 
        '''booleanOp(self, op, mesh1, mesh2)
Arguments:
	[in]	op = MFnMesh.BoolOperation
	[in]	mesh1 = MFnMesh
	[in]	mesh2 = MFnMesh


Computes the boolean between two meshes. The result is stored in the current  MFnMesh  instance. The current instance must point to a valid mesh, which can be empty. Such as mesh can result from using  MFnMeshData::create()  for example.'''
        pass

    def updateSurface(self): 
        '''updateSurface(self)

Signal that this polygonal mesh has changed and needs to redraw itself.'''
        pass

    def setFloatBlindData(self, compIDs, compType, blindDataId, attrName, data): 
        '''setFloatBlindData(self, compIDs, compType, blindDataId, attrName, data)
Arguments:
	[in]	compIDs = MIntArray
	[in]	compType = MFn.Type
	[in]	blindDataId = int
	[in]	attrName = MString
	[in]	data = MFloatArray


Set a values for a float blind data on an array of components. The arrays of values and components must be the same size.'''
        pass

    def getCurrentUVSetName(self, instance, setName): 
        '''getCurrentUVSetName(self, instance, setName)
Arguments:
	[out]	setName = MString
	[in]	instance = int


 This method is not available in Python. 
'''
        pass

    def setPoint(self, vertexId, pos, space): 
        '''setPoint(self, vertexId, pos, space)
Arguments:
	[in]	vertexId = int
	[in]	pos = MPoint
	[in]	space = MSpace.Space


Sets the position of specified vertex in the vertex list for this mesh.'''
        pass

    def assignColors(self, colorIds, colorSet): 
        '''assignColors(self, colorIds, colorSet)
Arguments:
	[in]	colorIds = MIntArray
	[in]	colorSet = MString


This method maps all colors for the mesh. The setColor/setColors method is used to create a color table for the mesh. After the table is created, this method is used to map those values to each polygon on a per-vertex basis. The setColor/setColors method should be called before the assignColors method.'''
        pass

    def numColorSets(self): 
        '''numColorSets(self) -> int
Returns: The number of color sets for the object


Returns the number of color sets for an object.'''
        pass

    def deleteVertex(self, vertexId, modifier): 
        '''deleteVertex(self, vertexId, modifier)
Arguments:
	[in]	vertexId = int
	[in]	modifier = MDGModifier


Delete this vertex.'''
        pass

    def lockVertexNormals(self, vertexList): 
        '''lockVertexNormals(self, vertexList)
Arguments:
	[in]	vertexList = MIntArray


Lock Shared Normals for these vertices.'''
        pass

    def getFaceVertexTangent(self, faceIndex, vertexIndex, space, uvSet, tangent): 
        '''getFaceVertexTangent(self, faceIndex, vertexIndex, space, uvSet, tangent)
Arguments:
	[in]	faceIndex = int
	[in]	vertexIndex = int
	[out]	tangent = MVector
	[in]	space = MSpace.Space
	[in]	uvSet = MString


Return the normalized tangent vector at a given face vertex.'''
        pass

    def setFaceVertexColor(self, faceIndex, localVertexIndex, color, modifier, rep): 
        '''setFaceVertexColor(self, faceIndex, localVertexIndex, color, modifier, rep)
Arguments:
	[in]	faceIndex = int
	[in]	localVertexIndex = int
	[in]	color = MColor
	[in]	modifier = MDGModifier
	[in]	rep = MFnMesh.MColorRepresentation


Set color of specified channels for this vertex in this face.'''
        pass

    def hasBlindDataComponentId(self, compID, compType): 
        '''hasBlindDataComponentId(self, compID, compType) -> bool
Returns: true: has the specified blind data, false: does not

Arguments:
	[in]	compID = int
	[in]	compType = MFn.Type


Does this component have any kind of blind data'''
        pass

    def setColors(self, colorArray, colorSet, rep): 
        '''setColors(self, colorArray, colorSet, rep)
Arguments:
	[in]	colorArray = MColorArray
	[in]	colorSet = MString
	[in]	rep = MFnMesh.MColorRepresentation


Sets all of the colors of specified channels for this mesh. The color array must be at least as large as the current color set size. You can determine the color set size by calling  numColors()  for the default color set, or numColors(colorSet) for a named color set.'''
        pass

    def removeFaceColors(self, faceList): 
        '''removeFaceColors(self, faceList)
Arguments:
	[in]	faceList = MIntArray


Remove previously set color these faces. For each face, the color will be unset for each vertex-face component in the face.'''
        pass

    def isEdgeSmooth(self, edgeId): 
        '''isEdgeSmooth(self, edgeId) -> bool
Returns: true The edge is smooth (soft) 
false The edge is hard

Arguments:
	[in]	edgeId = int


This method determines if the specified edge is smooth (soft).'''
        pass

    def getFloatBlindData(self, compType, blindDataId, attrName, compIDs, data): 
        '''getFloatBlindData(self, compType, blindDataId, attrName, compIDs, data)
Arguments:
	[in]	compType = MFn.Type
	[in]	blindDataId = int
	[in]	attrName = MString
	[out]	compIDs = MIntArray
	[out]	data = MFloatArray


Get the blind data value for the specified blind data attribute for all components of the given type. If the type of the attribute is not correct, this method will fail.'''
        pass

    def getColorRepresentation(self, colorSet): 
        '''getColorRepresentation(self, colorSet) -> MFnMesh.MColorRepresentation
Returns: kAlpha The color set contains only Alpha component 
kRGB The color set contains only RGB components 
kRGBA The color set contains RGBA components

Arguments:
	[in]	colorSet = MString


This method returns the color representation (RGB/RGBA/A) of a color set.'''
        pass

    def closestIntersection(self, raySource, rayDirection, faceIds, triIds, idsSorted, space, maxParam, testBothDirections, accelParams, hitPoint, hitRayParam, hitFace, hitTriangle, hitBary1, hitBary2, tolerance): 
        '''closestIntersection(self, raySource, rayDirection, faceIds, triIds, idsSorted, space, maxParam, testBothDirections, accelParams, hitPoint, hitRayParam, hitFace, hitTriangle, hitBary1, hitBary2, tolerance) -> bool

Arguments:
	[in]	raySource = MFloatPoint
	[in]	rayDirection = MFloatVector
	[in]	faceIds = MIntArray
	[in]	triIds = MIntArray
	[in]	idsSorted = bool
	[in]	space = MSpace.Space
	[in]	maxParam = float
	[in]	testBothDirections = bool
	[in]	accelParams = MMeshIsectAccelParams
	[in]	hitPoint = MFloatPoint
	[in]	hitRayParam = float
	[in]	hitFace = int
	[in]	hitTriangle = int
	[in]	hitBary1 = float
	[in]	hitBary2 = float
	[in]	tolerance = float


Finds the closest intersection of a ray starting at raySource and travelling in rayDirection with the mesh. If faceIds is non-NULL and triIds is NULL, then only the faces specified by faceIds will be considered for intersection. If both faceIds and triIds are non-NULL, then each pair of entries will be taken as a (face,triangle) pair to be considered for intersection, where triangles are numbered on each face starting from 0. Thus, the face-triangle pair (10,0) means the first triangle on face 10. If both faceIds and triIds are NULL, then all face-triangles in the mesh will be considered.'''
        pass

    def setSomeColors(self, colorIds, colorArray, colorSet, rep): 
        '''setSomeColors(self, colorIds, colorArray, colorSet, rep)
Arguments:
	[in]	colorIds = MIntArray
	[in]	colorArray = MColorArray
	[in]	colorSet = MString
	[in]	rep = MFnMesh.MColorRepresentation


Sets the specified colors of specified channels for this mesh.'''
        pass

    def getFaceVertexNormal(self, faceIndex, vertexIndex, space, normal): 
        '''getFaceVertexNormal(self, faceIndex, vertexIndex, space, normal)
Arguments:
	[in]	faceIndex = int
	[in]	vertexIndex = int
	[out]	normal = MVector
	[in]	space = MSpace.Space


Return a per-vertex-per-face normal for a given face (polygon) and given vertex.'''
        pass

    def getPointAtUV(self, polygonId, uvPoint, space, uvSet, tolerance, toThisPoint): 
        '''getPointAtUV(self, polygonId, uvPoint, space, uvSet, tolerance, toThisPoint)
Arguments:
	[in]	polygonId = int
	[out]	toThisPoint = MPoint
	[in]	uvPoint = float2
	[in]	space = MSpace.Space
	[in]	uvSet = MString
	[in]	tolerance = float


Return the position of the point at the given UV value in the current polygon.'''
        pass

    def setUVs(self, uArray, vArray, uvSet): 
        '''setUVs(self, uArray, vArray, uvSet)
Arguments:
	[in]	uArray = MFloatArray
	[in]	vArray = MFloatArray
	[in]	uvSet = MString


Sets all of the texture coordinates (uv's) for this mesh. The uv arrays must be of equal size and must be at least as large as the current UV set size. You can determine the UV set size by calling  numUVs()  for the default UV set, or numUVs(uvSet) for a named UV set.'''
        pass

    def getUVSetsInFamily(self, familyName, setNames): 
        '''getUVSetsInFamily(self, familyName, setNames)
Arguments:
	[in]	familyName = MString
	[out]	setNames = MStringArray


Get the names of the uv sets that belong to this set family. Per-instance sets will have multiple sets in a family, with each individual set applying to one or more instances. A set which is shared across all instances will be the sole member of its family and will share the same name as its family.'''
        pass

    def sortIntersectionFaceTriIds(self, faceIds, triIds): 
        '''sortIntersectionFaceTriIds(self, faceIds, triIds)
Arguments:
	[in]	faceIds = MIntArray
	[in]	triIds = MIntArray


Convenient routine for sorting faceIds or face/triangle ids before passing them into the  closestIntersection() ,  allIntersections() , or  anyIntersection()  methods. When using an acceleration structure with the intersection operation, it is essential that any faceId or faceId/triId arrays be sorted properly to ensure optimal performance.'''
        pass

    def getNormals(self, space, normals): 
        '''getNormals(self, space, normals)
Arguments:
	[out]	normals = MFloatVectorArray
	[in]	space = MSpace.Space


This method copies the normal list for this mesh into the given array. The normals are the per-polygon per-vertex normals. To find the normal for a particular vertex-face, use  getFaceNormalIds()  or  MItMeshPolygon::normalIndex  to get the index into the array.'''
        pass

    def clearColors(self, colorSet): 
        '''clearColors(self, colorSet)
Arguments:
	[in]	colorSet = MString


This method clears out all color for the mesh, and leaves behind an empty color set.'''
        pass

    def getPolygonUVid(self, polygonId, vertexIndex, uvSet, uvId): 
        '''getPolygonUVid(self, polygonId, vertexIndex, uvSet, uvId)
Arguments:
	[in]	polygonId = int
	[in]	vertexIndex = int
	[out]	uvId = int
	[in]	uvSet = MString


Get the id of the specified texture coordinate for a vertex in a polygon.'''
        pass

    def setFaceColor(self, color, faceIndex, rep): 
        '''setFaceColor(self, color, faceIndex, rep)
Arguments:
	[in]	color = MColor
	[in]	faceIndex = int
	[in]	rep = MFnMesh.MColorRepresentation


Set vertex-face Color of specified channels for all vertices on this face.'''
        pass

    def numFaceVertices(self): 
        '''numFaceVertices(self) -> int
Returns: The number of face-vertices for this mesh


Returns the number of face-vertices for this mesh.'''
        pass

    def setStringBlindData(self, compIDs, compType, blindDataId, attrName, data): 
        '''setStringBlindData(self, compIDs, compType, blindDataId, attrName, data)
Arguments:
	[in]	compIDs = MIntArray
	[in]	compType = MFn.Type
	[in]	blindDataId = int
	[in]	attrName = MString
	[in]	data = MStringArray


Set a values for a string blind data on an array of components. The arrays of values and components must be the same size.'''
        pass

    def numPolygons(self): 
        '''numPolygons(self) -> int
Returns: The number of polygons for this mesh


Returns the number of polygons for this mesh.'''
        pass

    def kInternalPoint(self):
        '''This is an enum of SplitPlacement.
Description: Split at a point within a face.
Value: 1'''
        pass

    def kInvalid(self):
        '''This is an enum of SplitPlacement.
Description: 
Value: 2'''
        pass

    def kOnEdge(self):
        '''This is an enum of SplitPlacement.
Description: Split at a position along an edge.
Value: 0'''
        pass

    class SplitPlacement:
        '''Non-functional class.  Values for this enum:
        kInternalPoint
        kInvalid
        kOnEdge
'''
        def __init__(self):
            pass

    def freeCachedIntersectionAccelerator(self): 
        '''freeCachedIntersectionAccelerator(self)

If the mesh has a cached intersection accelerator structure, then this routine forces it to be deleted. Ordinarily, these structures are cached so that series of calls to the  closestIntersection() ,  allIntersections() , and  anyIntersection()  method can reuse the same structure. Once the client is finished with these intersection operations, however, they are responsible for freeing the acceleration structure, which is what this method does.'''
        pass

    def intersect(self, raySource, rayDirection, tolerance, space, points, polygonIds): 
        '''intersect(self, raySource, rayDirection, tolerance, space, points, polygonIds) -> bool
Returns: true The given ray intersects this polygon 
false The given ray does not intersect this polygon

Arguments:
	[in]	raySource = MPoint
	[in]	rayDirection = MVector
	[out]	points = MPointArray
	[in]	tolerance = double
	[in]	space = MSpace.Space
	[out]	polygonIds = MIntArray


Determines whether the given ray intersects this polygon and if so, returns the points of intersection. The points of intersection will be in order of closest point to the raySource.'''
        pass

    def getBoolBlindData(self, compType, blindDataId, attrName, compIDs, data): 
        '''getBoolBlindData(self, compType, blindDataId, attrName, compIDs, data)
Arguments:
	[in]	compType = MFn.Type
	[in]	blindDataId = int
	[in]	attrName = MString
	[out]	compIDs = MIntArray
	[out]	data = MIntArray


Get the blind data value for the specified blind data attribute for all components of the given type. If the type of the attribute is not correct, this method will fail.'''
        pass

    def createInPlace(self, numVertices, numPolygons, vertexArray, polygonCounts, polygonConnects): 
        '''createInPlace(self, numVertices, numPolygons, vertexArray, polygonCounts, polygonConnects)
Arguments:
	[in]	numVertices = int
	[in]	numPolygons = int
	[in]	vertexArray = MFloatPointArray
	[in]	polygonCounts = MIntArray
	[in]	polygonConnects = MIntArray


Replaces the existing polygonal mesh with a new one specified by array of vertices and polygon connection information. This function will then operate on the replacement surface.'''
        pass

    def getNormalIds(self, normalCounts, normals): 
        '''getNormalIds(self, normalCounts, normals)
Arguments:
	[out]	normalCounts = MIntArray
	[out]	normals = MIntArray


Return normal indices for all vertices for a all faces. The normalIds can be used to index into an array returned by  MFnMesh::getNormals() ;'''
        pass

    def setEdgeSmoothing(self, edgeId, smooth): 
        '''setEdgeSmoothing(self, edgeId, smooth)
Arguments:
	[in]	edgeId = int
	[in]	smooth = bool


This method sets the specified edge to be hard or smooth (soft). You must use the  cleanupEdgeSmoothing  method after all the desired edges on your mesh have had setEdgeSmoothing done. Use the  updateSurface  method to indicate the mesh needs to be redrawn.'''
        pass

    def isPolygonConvex(self, faceIndex): 
        '''isPolygonConvex(self, faceIndex) -> bool
Returns: true The polygon is convex 
false The edge is concave

Arguments:
	[in]	faceIndex = int


This method determines if the specified polygon is convex.'''
        pass

    def getRawPoints(self): 
        '''getRawPoints(self) -> float*


This method returns a pointer to the internal vertex list for this mesh. The points are in local space.'''
        pass

    def stringBlindDataComponentId(self, compID, compType, blindDataId, attrName): 
        '''stringBlindDataComponentId(self, compID, compType, blindDataId, attrName) -> MString
Returns: Blind data.

Arguments:
	[in]	compID = int
	[in]	compType = MFn.Type
	[in]	blindDataId = int
	[in]	attrName = MString


Get the blind data value for the specified blind data attribute of the specified component. If the type of the attribute is not correct, this method will fail.'''
        pass

    def getFaceVertexTangents(self, faceIndex, space, uvSet, tangents): 
        '''getFaceVertexTangents(self, faceIndex, space, uvSet, tangents)
Arguments:
	[in]	faceIndex = int
	[out]	tangents = MFloatVectorArray
	[in]	space = MSpace.Space
	[in]	uvSet = MString


Return all per-vertex-per-face tangents for a given face.'''
        pass

    def createColorSet(self, colorSetName, modifier, clamped, rep, instances): 
        '''createColorSet(self, colorSetName, modifier, clamped, rep, instances)
Arguments:
	[in]	colorSetName = MString
	[in]	modifier = MDGModifier
	[in]	clamped = bool
	[in]	rep = MFnMesh.MColorRepresentation
	[in]	instances = MUintArray


 This method is not available in Python. 
'''
        pass

    def anyIntersection(self, raySource, rayDirection, faceIds, triIds, idsSorted, space, maxParam, testBothDirections, accelParams, hitPoint, hitRayParam, hitFace, hitTriangle, hitBary1, hitBary2, tolerance): 
        '''anyIntersection(self, raySource, rayDirection, faceIds, triIds, idsSorted, space, maxParam, testBothDirections, accelParams, hitPoint, hitRayParam, hitFace, hitTriangle, hitBary1, hitBary2, tolerance) -> bool

Arguments:
	[in]	raySource = MFloatPoint
	[in]	rayDirection = MFloatVector
	[in]	faceIds = MIntArray
	[in]	triIds = MIntArray
	[in]	idsSorted = bool
	[in]	space = MSpace.Space
	[in]	maxParam = float
	[in]	testBothDirections = bool
	[in]	accelParams = MMeshIsectAccelParams
	[in]	hitPoint = MFloatPoint
	[in]	hitRayParam = float
	[in]	hitFace = int
	[in]	hitTriangle = int
	[in]	hitBary1 = float
	[in]	hitBary2 = float
	[in]	tolerance = float


Finds any intersection of a ray starting at raySource and travelling in rayDirection with the mesh. If faceIds is non-NULL and triIds is NULL, then only the faces specified by faceIds will be considered for intersection. If both faceIds and triIds are non-NULL, then each pair of entries will be taken as a (face,triangle) pair to be considered for intersection, where triangles are numbered on each face starting from 0. Thus, the face-triangle pair (10,0) means the first triangle on face 10. If both faceIds and triIds are NULL, then all face-triangles in the mesh will be considered.'''
        pass

    def getFaceUVSetNames(self, polygonId, setNames): 
        '''getFaceUVSetNames(self, polygonId, setNames)
Arguments:
	[in]	polygonId = int
	[out]	setNames = MStringArray


This method returns the list of UV sets mapped to a face.'''
        pass

    def copyUVSet(self, fromName, toName, modifier): 
        '''copyUVSet(self, fromName, toName, modifier)
Arguments:
	[in]	fromName = MString
	[in]	toName = MString
	[in]	modifier = MDGModifier


 This method is not available in Python. 
'''
        pass

    def removeVertexColors(self, vertexList): 
        '''removeVertexColors(self, vertexList)
Arguments:
	[in]	vertexList = MIntArray


Remove color from these vertices.'''
        pass

    def isNormalLocked(self, normalId): 
        '''isNormalLocked(self, normalId) -> bool

Arguments:
	[in]	normalId = int

'''
        pass

    def numUVs(self, uvSet): 
        '''numUVs(self, uvSet) -> int
Returns: The number of texture coordinates

Arguments:
	[in]	uvSet = MString


Returns the number of texture (uv) coordinates for this mesh. The uv's are stored in a list which is referenced by polygons requiring textures on a per-polygon per-vertex basis. This method returns the number of elements in this list.'''
        pass

    def deleteFace(self, faceId, modifier): 
        '''deleteFace(self, faceId, modifier)
Arguments:
	[in]	faceId = int
	[in]	modifier = MDGModifier


Delete this face. The method will return failure if an attempt is made to delete the last polygonal face in the object.'''
        pass

    def getRawNormals(self): 
        '''getRawNormals(self) -> float*


This method returns a pointer to the internal normal list for this mesh. The normals are in local space and are the per-polygon per-vertex normals. To find the normal for a particular vertex-face, use  getFaceNormalIds()  or  MItMeshPolygon::normalIndex  to get the index into the array.'''
        pass

    def setIntBlindData(self, compIDs, compType, blindDataId, attrName, data): 
        '''setIntBlindData(self, compIDs, compType, blindDataId, attrName, data)
Arguments:
	[in]	compIDs = MIntArray
	[in]	compType = MFn.Type
	[in]	blindDataId = int
	[in]	attrName = MString
	[in]	data = MIntArray


Set a values for an integer blind data on an array of components. The arrays of values and components must be the same size.'''
        pass

    def extrudeFaces(self, faceList, extrusionCount, translation, extrudeTogether): 
        '''extrudeFaces(self, faceList, extrusionCount, translation, extrudeTogether)
Arguments:
	[in]	faceList = MIntArray
	[in]	extrusionCount = int
	[in]	translation = MFloatVector
	[in]	extrudeTogether = bool


This function extrudes a set of faces. The resulting mesh will have extra parallelograms coming out of the edges of the given polygons going to the new extruded edges. The extrusionCount argument is the number of subsequent extrusions per polygon and represents the number of faces that will be created for each edge of the polygons in the list.'''
        pass

    def setColor(self, colorId, color, colorSet, rep): 
        '''setColor(self, colorId, color, colorSet, rep)
Arguments:
	[in]	colorId = int
	[in]	color = MColor
	[in]	colorSet = MString
	[in]	rep = MFnMesh.MColorRepresentation


Sets the specified color values of specified channels. The colorId is the element in the color list that will be set. If the colorId is greater than or equal to  numColors()  then the color list will be grown to accommodate the specified color.'''
        pass

    def setFaceVertexNormal(self, normalIn, faceId, vertexId, space, modifier): 
        '''setFaceVertexNormal(self, normalIn, faceId, vertexId, space, modifier)
Arguments:
	[in]	normalIn = MVector
	[in]	faceId = int
	[in]	vertexId = int
	[in]	space = MSpace.Space
	[in]	modifier = MDGModifier


Set Normal for this face/vertex pair'''
        pass

    def deleteEdge(self, edgeId, modifier): 
        '''deleteEdge(self, edgeId, modifier)
Arguments:
	[in]	edgeId = int
	[in]	modifier = MDGModifier


Delete this edge.'''
        pass

    def currentColorSetName(self, instance): 
        '''currentColorSetName(self, instance) -> MString

Arguments:
	[in]	instance = int


Get the name of the "current" or "working" color set. The "current" color set is the color set which is used for color operations when no color set is explcitly specified.'''
        pass

    def getPolygonNormal(self, polygonId, space, normal): 
        '''getPolygonNormal(self, polygonId, space, normal)
Arguments:
	[in]	polygonId = int
	[out]	normal = MVector
	[in]	space = MSpace.Space


Return the normal at the given polygon. The returned normal is a per-polygon normal. See the class description for more information on normals.'''
        pass

    def setUV(self, uvId, u, v, uvSet): 
        '''setUV(self, uvId, u, v, uvSet)
Arguments:
	[in]	uvId = int
	[in]	u = float
	[in]	v = float
	[in]	uvSet = MString


Sets the specified texture coordinate. The uvId is the element in the uv list that will be set. If the uvId is greater than or equal to  numUVs()  then the uv list will be grown to accommodate the specified uv. If a named uv set is given, the largest uvId must be larger than numUVs(uvSet).'''
        pass

    def assignUV(self, polygonId, vertexIndex, uvId, uvSet): 
        '''assignUV(self, polygonId, vertexIndex, uvId, uvSet)
Arguments:
	[in]	polygonId = int
	[in]	vertexIndex = int
	[in]	uvId = int
	[in]	uvSet = MString


Maps a texture coordinate to a specified vertex of a polygon.'''
        pass

    def getTriangles(self, triangleCounts, triangleVertices): 
        '''getTriangles(self, triangleCounts, triangleVertices)
Arguments:
	[out]	triangleCounts = MIntArray
	[out]	triangleVertices = MIntArray


Returns the number of triangles for every polygon face and the vertex Ids of each triangle vertex. The triangleVertices array holds each vertex for each triangle in sequence, so is three times longer than the triangleCounts array'''
        pass

    def clearGlobalIntersectionAcceleratorInfo(self): 
        '''clearGlobalIntersectionAcceleratorInfo(self)
'''
        pass

    def polygonVertexCount(self, polygonId): 
        '''polygonVertexCount(self, polygonId) -> int
Returns: The number of vertices for the specified polygon

Arguments:
	[in]	polygonId = int


Returns the number of vertices for the specified polygon.'''
        pass

    def isColorSetPerInstance(self, name): 
        '''isColorSetPerInstance(self, name) -> bool
Returns: true if the set is per-instance

Arguments:
	[in]	name = MString


Return true if this color set is per-instance, and false if it is shared across all instances. The name provided may be an individual set name or a set family name.'''
        pass

    def getClosestNormal(self, toThisPoint, space, theNormal, closestPolygon): 
        '''getClosestNormal(self, toThisPoint, space, theNormal, closestPolygon)
Arguments:
	[in]	toThisPoint = MPoint
	[out]	theNormal = MVector
	[in]	space = MSpace.Space
	[out]	closestPolygon = int


Returns the closest point on this surface to the given point. This method also returns the surface normal at that point.'''
        pass

    def getClosestPointAndNormal(self, toThisPoint, space, theClosestPoint, theNormal, closestPolygon): 
        '''getClosestPointAndNormal(self, toThisPoint, space, theClosestPoint, theNormal, closestPolygon)
Arguments:
	[in]	toThisPoint = MPoint
	[out]	theClosestPoint = MPoint
	[out]	theNormal = MVector
	[in]	space = MSpace.Space
	[out]	closestPolygon = int


Returns the closest point on this surface to the given point. This method also returns the surface normal at that point.'''
        pass

    def getTangentId(self, faceIndex, vertexIndex): 
        '''getTangentId(self, faceIndex, vertexIndex) -> int

Arguments:
	[in]	faceIndex = int
	[in]	vertexIndex = int


Return the tangent index for a given face vertex.'''
        pass

    def getVertexColors(self, colorSet, defaultUnsetColor, colors): 
        '''getVertexColors(self, colorSet, defaultUnsetColor, colors)
Arguments:
	[out]	colors = MColorArray
	[in]	colorSet = MString
	[in]	defaultUnsetColor = MColor


Get colors for all Vertices of the given colorSet. If the colorSet is not specified, the default color set will be used. If no vertex/face has color for that vertex, the entry returned will be defaultUnsetColor. If the defaultUnsetColor is not given, then (-1, -1, -1, -1) will be used. If a color was set for some or all the faces for that vertex, an average of those verted/face values where the color has been set will be returned.'''
        pass

    def getPolygonTriangleVertices(self, polygonId, triangleId, vertexList): 
        '''getPolygonTriangleVertices(self, polygonId, triangleId, vertexList)
Arguments:
	[in]	polygonId = int
	[in]	triangleId = int
	[out]	vertexList = int3


This method retrieves the  object-relative (mesh-relative/global)  vertex indices for the specified triangle in the specified polygon. The indices refer to the elements in the array returned by the 'getPoints' method.'''
        pass

    def cleanupEdgeSmoothing(self): 
        '''cleanupEdgeSmoothing(self)

This method updates the mesh after setEdgeSmoothing has been done. This should be called only once, after all the desired edges have been had their soothing set. If you don't call this method, the normals may not be correct, and the object will look odd in shaded mode.'''
        pass

    def createBlindDataType(self, blindDataId, longNames, shortNames, formatNames): 
        '''createBlindDataType(self, blindDataId, longNames, shortNames, formatNames)
Arguments:
	[in]	blindDataId = int
	[in]	longNames = MStringArray
	[in]	shortNames = MStringArray
	[in]	formatNames = MStringArray


Create a new blind data type. If the type id is already in use, this method will fail. Format names must be one of "int" "float" "double" "boolean" "string" "binary".'''
        pass

    def numEdges(self): 
        '''numEdges(self) -> int
Returns: The number of edges for this mesh


Returns the number of edges for this mesh.'''
        pass

    def deleteColorSet(self, colorSetName, modifier, currentSelection): 
        '''deleteColorSet(self, colorSetName, modifier, currentSelection)
Arguments:
	[in]	colorSetName = MString
	[in]	modifier = MDGModifier
	[in]	currentSelection = MSelectionList


Deletes a named color set from the object. If a color set with the given name cannot be found, then no color set will be deleted.'''
        pass

    def assignUVs(self, uvCounts, uvIds, uvSet): 
        '''assignUVs(self, uvCounts, uvIds, uvSet)
Arguments:
	[in]	uvCounts = MIntArray
	[in]	uvIds = MIntArray
	[in]	uvSet = MString


This method maps all texture coordinates for the mesh. The setUV/setUVs method is used to create the texture coordinate table for the mesh. After the table is created, this method is used to map those values to each polygon on a per-vertex basis. The setUV/setUVs method should be called before the assignUVs method.'''
        pass

    def getConnectedSetsAndMembers(self, instanceNumber, renderableSetsOnly, sets, comps): 
        '''getConnectedSetsAndMembers(self, instanceNumber, renderableSetsOnly, sets, comps)
Arguments:
	[in]	instanceNumber = int
	[out]	sets = MObjectArray
	[out]	comps = MObjectArray
	[in]	renderableSetsOnly = bool


Returns all the sets connected to the specified instance of this mesh. For each set in the "sets" array there is a corresponding entry in the "comps" array which are all the components in that set. If the entire object is in a set, then the corresponding entry in the comps array will have no elements in it.'''
        pass

    def subdivideFaces(self, faceList, divisionCount): 
        '''subdivideFaces(self, faceList, divisionCount)
Arguments:
	[in]	faceList = MIntArray
	[in]	divisionCount = int


This function subdivides multiple faces. This method only accepts faces that are three of four-sided. The operation adds a vertex in the middle of each given face and connects it to the middle of every edge in the given face. This results in three or four new faces for each original face.'''
        pass

    def createColorSetWithName(self, colorSetName, modifier, instances): 
        '''createColorSetWithName(self, colorSetName, modifier, instances) -> MString
Returns: The resulting name of the color set.

Arguments:
	[in]	colorSetName = MString
	[in]	modifier = MDGModifier
	[in]	instances = MUintArray


Create a new empty color set for this mesh. If the name passed in is empty (zero length), or a color set with the same name already exists, then a new unique name is generated and used as the new color set's name.'''
        pass

    def getColorIndex(self, faceIndex, localVertexIndex, colorSet, colorIndex): 
        '''getColorIndex(self, faceIndex, localVertexIndex, colorSet, colorIndex)
Arguments:
	[in]	faceIndex = int
	[in]	localVertexIndex = int
	[out]	colorIndex = int
	[in]	colorSet = MString


Get an index into the array returned by getColors.'''
        pass

    def deleteUVSet(self, setName, modifier, currentSelection): 
        '''deleteUVSet(self, setName, modifier, currentSelection)
Arguments:
	[in]	setName = MString
	[in]	modifier = MDGModifier
	[in]	currentSelection = MSelectionList


Deletes a named uv set from the object. If a uv set with the given name cannot be found, then no uv set will be deleted.'''
        pass

    def getUVs(self, uvSet, uArray, vArray): 
        '''getUVs(self, uvSet, uArray, vArray)
Arguments:
	[out]	uArray = MFloatArray
	[out]	vArray = MFloatArray
	[in]	uvSet = MString


This method copies the texture coordinate list for this mesh into the given uv arrays.'''
        pass

    def subdivideEdges(self, edgeList, divisionCount): 
        '''subdivideEdges(self, edgeList, divisionCount)
Arguments:
	[in]	edgeList = MIntArray
	[in]	divisionCount = int


This function subdivides edges at regular intervals. The divisionCount argument is the number of subdivisions per edges and represents the number of new vertices created on each edge.'''
        pass

    def create(self, numVertices, numPolygons, vertexArray, polygonCounts, polygonConnects, uArray, vArray, parentOrOwner): 
        '''create(self, numVertices, numPolygons, vertexArray, polygonCounts, polygonConnects, uArray, vArray, parentOrOwner) -> MObject
Returns: If parentOrOwner is NULL then the transform for this surface is returned 
If parentOrOwner is a DAG object then the new surface shape is returned 
The surface geometry is returned if parentOrOwner is of type kMeshData

Arguments:
	[in]	numVertices = int
	[in]	numPolygons = int
	[in]	vertexArray = MPointArray
	[in]	polygonCounts = MIntArray
	[in]	polygonConnects = MIntArray
	[in]	uArray = MFloatArray
	[in]	vArray = MFloatArray
	[in]	parentOrOwner = MObject


Creates a new polygonal mesh given an array of vertices, polygon connection information, UV information, and sets this function set to operate on the new surface.'''
        pass

    def setCreaseEdges(self, edgeIds, creaseData): 
        '''setCreaseEdges(self, edgeIds, creaseData)
Arguments:
	[in]	edgeIds = MUintArray
	[in]	creaseData = MDoubleArray


This method sets the specified edges of the mesh as crease edges.'''
        pass

    def getVertexNormal(self, vertexId, angleWeighted, space, normal): 
        '''getVertexNormal(self, vertexId, angleWeighted, space, normal)
Arguments:
	[in]	vertexId = int
	[in]	angleWeighted = bool
	[out]	normal = MVector
	[in]	space = MSpace.Space


Return the normal at the given vertex. The returned normal is a single per-vertex normal, so unshared normals at a vertex will be averaged. See the class description for more information on normals.'''
        pass

    def getFaceVertexColors(self, colorSet, defaultUnsetColor, colors): 
        '''getFaceVertexColors(self, colorSet, defaultUnsetColor, colors)
Arguments:
	[out]	colors = MColorArray
	[in]	colorSet = MString
	[in]	defaultUnsetColor = MColor


Get colors for all vertex/faces of the given color set. If the color set is not specified, the default color set will be used. If no vertex/face has color for that vertex, the entry returned will be defaultUnsetColor. If defaultUnsetColor is not given, then (-1, -1, -1, -1) will be used. If a color was set for some but not all the faces for that vertex, the ones where the color has not been explicitly set will have (0,0,0). If a vertex has shared color, the same value will be set for all its vertes/faces.'''
        pass

    def getAssociatedUVSetInstances(self, uvSetName, instances): 
        '''getAssociatedUVSetInstances(self, uvSetName, instances)
Arguments:
	[in]	uvSetName = MString
	[out]	instances = MIntArray


Get a list of the instance numbers associated with this uv map. If the uv map is shared across all instances, an empty array will be returned.'''
        pass

    def setVertexColor(self, color, vertexIndex, modifier, rep): 
        '''setVertexColor(self, color, vertexIndex, modifier, rep)
Arguments:
	[in]	color = MColor
	[in]	vertexIndex = int
	[in]	modifier = MDGModifier
	[in]	rep = MFnMesh.MColorRepresentation


Set color of specified channels for this vertex. The color is set for the vertex-face in each face that the vertex belongs to.'''
        pass

    def getColorSetNames(self, setNames): 
        '''getColorSetNames(self, setNames)
Arguments:
	[out]	setNames = MStringArray


Get the names of all of the colors sets on this object.'''
        pass

    def getDoubleBlindData(self, compType, blindDataId, attrName, compIDs, data): 
        '''getDoubleBlindData(self, compType, blindDataId, attrName, compIDs, data)
Arguments:
	[in]	compType = MFn.Type
	[in]	blindDataId = int
	[in]	attrName = MString
	[out]	compIDs = MIntArray
	[out]	data = MDoubleArray


Get the blind data value for the specified blind data attribute for all components of the given type. If the type of the attribute is not correct, this method will fail.'''
        pass

    def getIntBlindData(self, compType, blindDataId, attrName, compIDs, data): 
        '''getIntBlindData(self, compType, blindDataId, attrName, compIDs, data)
Arguments:
	[in]	compType = MFn.Type
	[in]	blindDataId = int
	[in]	attrName = MString
	[out]	compIDs = MIntArray
	[out]	data = MIntArray


Get the blind data value for the specified blind data attribute of the given type of component. If the type of the attribute is not correct, this method will fail.'''
        pass

    def type(self): 
        '''type(self) -> MFn.Type

'''
        pass

    def hasColorChannels(self, colorSet): 
        '''hasColorChannels(self, colorSet) -> bool
Returns: true The color set has RGB components 
false The color set doesn't have RGB components

Arguments:
	[in]	colorSet = MString


This method returns if the color set has RGB components.'''
        pass

    def setVertexNormal(self, normalIn, vertexId, space, modifier): 
        '''setVertexNormal(self, normalIn, vertexId, space, modifier)
Arguments:
	[in]	normalIn = MVector
	[in]	vertexId = int
	[in]	space = MSpace.Space
	[in]	modifier = MDGModifier


Set Shared Normal for this vertex'''
        pass

    def isUVSetPerInstance(self, name): 
        '''isUVSetPerInstance(self, name) -> bool
Returns: true if the set is per-instance

Arguments:
	[in]	name = MString


Return true if this set is per-instance, and false if it is shared across all instances. The name provided may be an individual set name or a set family name.'''
        pass

    def duplicateFaces(self, faceList, translation): 
        '''duplicateFaces(self, faceList, translation)
Arguments:
	[in]	faceList = MIntArray
	[in]	translation = MFloatVector


This function duplicates a set of faces and detaches them from the rest of the mesh. The resulting mesh will contain one more independant piece of geometry.'''
        pass

    def getBinormals(self, space, uvSet, binormals): 
        '''getBinormals(self, space, uvSet, binormals)
Arguments:
	[out]	binormals = MFloatVectorArray
	[in]	space = MSpace.Space
	[in]	uvSet = MString


Return the binormal vectors for all face vertices.'''
        pass

    def setSomeUVs(self, uvIds, uArray, vArray, uvSet): 
        '''setSomeUVs(self, uvIds, uArray, vArray, uvSet)
Arguments:
	[in]	uvIds = MIntArray
	[in]	uArray = MFloatArray
	[in]	vArray = MFloatArray
	[in]	uvSet = MString


Sets the specified texture coordinates (UV's) for this mesh. The uv arrays and uvId array must be of equal size. If the largest uvId in the array is larger than  numUVs()  then the uv list for this mesh will be grown to accommodate the new uv values. If a named uv set is given, the array will be grown when the largest uvId is larger than numUVs(uvSet).'''
        pass

    def createUVSet(self, uvSetName, modifier, instances): 
        '''createUVSet(self, uvSetName, modifier, instances)
Arguments:
	[in]	uvSetName = MString
	[in]	modifier = MDGModifier
	[in]	instances = MUintArray


 This method is not available in Python. 
'''
        pass

    def kIntersection(self):
        '''This is an enum of BoolOperation.
Description: Boolean interesection.
Value: 1'''
        pass

    def kUnion(self):
        '''This is an enum of BoolOperation.
Description: Boolean union.
Value: 3'''
        pass

    def kDifference(self):
        '''This is an enum of BoolOperation.
Description: Boolean difference.
Value: 2'''
        pass

    class BoolOperation:
        '''Non-functional class.  Values for this enum:
        kIntersection
        kUnion
        kDifference
'''
        def __init__(self):
            pass

    def isBlindDataTypeUsed(self, blindDataId): 
        '''isBlindDataTypeUsed(self, blindDataId) -> bool
Returns: true: Id in use, false: id not in use

Arguments:
	[in]	blindDataId = int


Is this BlindData type id is already in use in this scene?'''
        pass

    def getUV(self, uvId, uvSet, u, v): 
        '''getUV(self, uvId, uvSet, u, v)
Arguments:
	[in]	uvId = int
	[out]	u = float
	[out]	v = float
	[in]	uvSet = MString


Get the value of the specified texture coordinate from this mesh's uv list. The uvId is the element in the uv list that will be retrieved.'''
        pass

    def copy(self, source, parentOrOwner): 
        '''copy(self, source, parentOrOwner) -> MObject
Returns: If parentOrOwner is NULL then the transform for this surface is returned 
If parentOrOwner is a DAG object then the new surface shape is returned 
The surface geometry is returned if parentOrOwner is of type kMeshData

Arguments:
	[in]	source = MObject
	[in]	parentOrOwner = MObject


This method creates a copy of a given source mesh. After the copy this function set will operate on the new mesh.'''
        pass

    def collapseFaces(self, faceList): 
        '''collapseFaces(self, faceList)
Arguments:
	[in]	faceList = MIntArray


This function collapse faces into vertices. Non-adjacent faces will be collapsed individually so that each pieces of adjacent faces turn into one vertex.'''
        pass

    def clearUVs(self, uvSet): 
        '''clearUVs(self, uvSet)
Arguments:
	[in]	uvSet = MString


This method clears out all texture coordinates for the mesh, and leaves behind an empty UVset.'''
        pass

    def createUVSetWithName(self, uvSetName, modifier, instances): 
        '''createUVSetWithName(self, uvSetName, modifier, instances) -> MString
Returns: The name used for the UV set. May be different then the given name if a new name needed to be generated.

Arguments:
	[in]	uvSetName = MString
	[in]	modifier = MDGModifier
	[in]	instances = MUintArray


Create a new empty uv set for this mesh. If the name passed in is empty (zero length), or a uv set with the same name already exists, then a new unique name is generated and used as the new uvset's name.'''
        pass

    def getSmoothMeshDisplayOptions(self, options): 
        '''getSmoothMeshDisplayOptions(self, options)
Arguments:
	[out]	options = MMeshSmoothOptions


Retrieve the current display smoothing options for the mesh'''
        pass

    def extrudeEdges(self, edgeList, extrusionCount, translation, extrudeTogether): 
        '''extrudeEdges(self, edgeList, extrusionCount, translation, extrudeTogether)
Arguments:
	[in]	edgeList = MIntArray
	[in]	extrusionCount = int
	[in]	translation = MFloatVector
	[in]	extrudeTogether = bool


This function extrudes edges. The resulting mesh will have extra parallelograms coming out of the given edges and going to the new extruded edges. The extrusionCount argument is the number of subsequent extrusions per edges and represents the number of polygons that will be created from each given edge to the extruded edges.'''
        pass

    def hasAlphaChannels(self, colorSet): 
        '''hasAlphaChannels(self, colorSet) -> bool
Returns: true The color set has Alpha component 
false The color set doesn't have Alpha component

Arguments:
	[in]	colorSet = MString


This method returns true if the color set has Alpha component.'''
        pass

    def allIntersections(self, raySource, rayDirection, faceIds, triIds, idsSorted, space, maxParam, testBothDirections, accelParams, sortHits, hitPoints, hitRayParams, hitFaces, hitTriangles, hitBary1s, hitBary2s, tolerance): 
        '''allIntersections(self, raySource, rayDirection, faceIds, triIds, idsSorted, space, maxParam, testBothDirections, accelParams, sortHits, hitPoints, hitRayParams, hitFaces, hitTriangles, hitBary1s, hitBary2s, tolerance) -> bool

Arguments:
	[in]	raySource = MFloatPoint
	[in]	rayDirection = MFloatVector
	[in]	faceIds = MIntArray
	[in]	triIds = MIntArray
	[in]	idsSorted = bool
	[in]	space = MSpace.Space
	[in]	maxParam = float
	[in]	testBothDirections = bool
	[in]	accelParams = MMeshIsectAccelParams
	[in]	sortHits = bool
	[in]	hitPoints = MFloatPointArray
	[in]	hitRayParams = MFloatArray
	[in]	hitFaces = MIntArray
	[in]	hitTriangles = MIntArray
	[in]	hitBary1s = MFloatArray
	[in]	hitBary2s = MFloatArray
	[in]	tolerance = float


Finds all intersections of a ray starting at raySource and travelling in rayDirection with the mesh. If faceIds is non-NULL and triIds is NULL, then only the faces specified by faceIds will be considered for intersection. If both faceIds and triIds are non-NULL, then each pair of entries will be taken as a (face,triangle) pair to be considered for intersection, where triangles are numbered on each face starting from 0. Thus, the face-triangle pair (10,0) means the first triangle on face 10. If both faceIds and triIds are NULL, then all face-triangles in the mesh will be considered.'''
        pass

    def className(self): 
        '''className(self) -> char*

'''
        pass

    def getPoints(self, space, vertexArray): 
        '''getPoints(self, space, vertexArray)
Arguments:
	[out]	vertexArray = MPointArray
	[in]	space = MSpace.Space


This method copies the vertex list for this mesh into the given point array.'''
        pass

    def getCurrentColorSetName(self, instance, setName): 
        '''getCurrentColorSetName(self, instance, setName)
Arguments:
	[out]	setName = MString
	[in]	instance = int


 This method is not available in Python. 
'''
        pass

    def getColors(self, colorSet, defaultUnsetColor, colorArray): 
        '''getColors(self, colorSet, defaultUnsetColor, colorArray)
Arguments:
	[out]	colorArray = MColorArray
	[in]	colorSet = MString
	[in]	defaultUnsetColor = MColor


This method copies the color array for this mesh into the given color array. Use the index returned by getColorIndex to access the array. If the color is not set for a vertex, defaultUnsetColor will be return. If defaultUnsetColor is not set, (0,0,0,1) will be return.'''
        pass

    def setFaceColors(self, colors, faceList, rep): 
        '''setFaceColors(self, colors, faceList, rep)
Arguments:
	[in]	colors = MColorArray
	[in]	faceList = MIntArray
	[in]	rep = MFnMesh.MColorRepresentation


Set color of specified channels for these faces. The color will be set for each vertex-face component of a face.'''
        pass

    def uniformGridParams(self, xDiv, yDiv, zDiv): 
        '''uniformGridParams(self, xDiv, yDiv, zDiv) -> MMeshIsectAccelParams

Arguments:
	[in]	xDiv = int
	[in]	yDiv = int
	[in]	zDiv = int


Creates a MMeshIsectAccelParams configuration object to pass to the methods  MFnMesh::closestIntersection() ,  MFnMesh::anyIntersection() , or  MFnMesh::allIntersections() . This object specifies that a uniform voxel grid structure should be used by the intersection routines to speed up their operation. This object specifies the number of voxel cells to be used in the x, y, and z dimensions. The grid acceleration structure will be cached with the mesh, so that if the same MMeshIsectAccelParams configuration is used on the next intersect call, the acceleration structure will not need to be rebuilt.'''
        pass

    def unlockFaceVertexNormals(self, faceList, vertexList): 
        '''unlockFaceVertexNormals(self, faceList, vertexList)
Arguments:
	[in]	faceList = MIntArray
	[in]	vertexList = MIntArray


Unlock Normals for these face/vertex pairs'''
        pass

    def setBoolBlindData(self, compIDs, compType, blindDataId, attrName, data): 
        '''setBoolBlindData(self, compIDs, compType, blindDataId, attrName, data)
Arguments:
	[in]	compIDs = MIntArray
	[in]	compType = MFn.Type
	[in]	blindDataId = int
	[in]	attrName = MString
	[in]	data = MIntArray


Set a values for a boolean blind data on an array of components. The arrays of values and components must be the same size.'''
        pass

    def getUVAtPoint(self, pt, space, uvSet, closestPolygon, uvPoint): 
        '''getUVAtPoint(self, pt, space, uvSet, closestPolygon, uvPoint)
Arguments:
	[in]	pt = MPoint
	[out]	uvPoint = float2
	[in]	space = MSpace.Space
	[in]	uvSet = MString
	[in]	closestPolygon = int


Find the point closet to the given point, and return the UV value at that point.'''
        pass

    def getAssignedUVs(self, uvSet, uvCounts, uvIds): 
        '''getAssignedUVs(self, uvSet, uvCounts, uvIds)
Arguments:
	[out]	uvCounts = MIntArray
	[out]	uvIds = MIntArray
	[in]	uvSet = MString


Get assigned UVs. This method finds all texture coordinates for the mesh that have been mapped, and returns them in the same format as the assignUVs.'''
        pass

    def getHoles(self, holeInfoArray, holeVertexArray): 
        '''getHoles(self, holeInfoArray, holeVertexArray) -> int

Arguments:
	[in]	holeInfoArray = MIntArray
	[in]	holeVertexArray = MIntArray


Retrieves a list of the holes in the polygon.'''
        pass

    def setCurrentColorSetName(self, setName, modifier, currentSelection): 
        '''setCurrentColorSetName(self, setName, modifier, currentSelection)
Arguments:
	[in]	setName = MString
	[in]	modifier = MDGModifier
	[in]	currentSelection = MSelectionList


Set the "current" or "working" color set for this object. The "current" color set is the set to use by functions that do not have a specific color set defined.'''
        pass

    def getCreaseVertices(self, vertexIds, creaseData): 
        '''getCreaseVertices(self, vertexIds, creaseData)
Arguments:
	[out]	vertexIds = MUintArray
	[out]	creaseData = MDoubleArray


This method returns the crease vertices of the mesh, and also the crease data associated with those vertices.'''
        pass

    def kRGBA(self):
        '''This is an enum of MColorRepresentation.
Description: Red, green, blue and alpha.
Value: 4'''
        pass

    def kAlpha(self):
        '''This is an enum of MColorRepresentation.
Description: Alpha only.
Value: 1'''
        pass

    def kRGB(self):
        '''This is an enum of MColorRepresentation.
Description: Red, green and blue only.
Value: 3'''
        pass

    class MColorRepresentation:
        '''Non-functional class.  Values for this enum:
        kRGBA
        kAlpha
        kRGB
'''
        def __init__(self):
            pass

    def setSmoothMeshDisplayOptions(self, options): 
        '''setSmoothMeshDisplayOptions(self, options)
Arguments:
	[in]	options = MMeshSmoothOptions


Sets the current display smoothing options for the mesh'''
        pass

    def setFaceVertexColors(self, colors, faceList, vertexList, modifier, rep): 
        '''setFaceVertexColors(self, colors, faceList, vertexList, modifier, rep)
Arguments:
	[in]	colors = MColorArray
	[in]	faceList = MIntArray
	[in]	vertexList = MIntArray
	[in]	modifier = MDGModifier
	[in]	rep = MFnMesh.MColorRepresentation


Set colors of specified channels for these face/vertex pairs.'''
        pass

    def getFaceVertexNormals(self, faceIndex, space, normals): 
        '''getFaceVertexNormals(self, faceIndex, space, normals)
Arguments:
	[in]	faceIndex = int
	[out]	normals = MFloatVectorArray
	[in]	space = MSpace.Space


Return all per-vertex-per-face normals for a given face.'''
        pass

    def setDoubleBlindData(self, compIDs, compType, blindDataId, attrName, data): 
        '''setDoubleBlindData(self, compIDs, compType, blindDataId, attrName, data)
Arguments:
	[in]	compIDs = MIntArray
	[in]	compType = MFn.Type
	[in]	blindDataId = int
	[in]	attrName = MString
	[in]	data = MDoubleArray


Set a values for a double blind data on an array of components. The arrays of values and components must be the same size.'''
        pass

    def split(self, placements, edgeList, edgeFactors, internalPoints): 
        '''split(self, placements, edgeList, edgeFactors, internalPoints)
Arguments:
	[in]	placements = MIntArray
	[in]	edgeList = MIntArray
	[in]	edgeFactors = MFloatArray
	[in]	internalPoints = MFloatPointArray


This function splits a set of edges and faces in a continuous manner.'''
        pass

    def getFaceVertexBinormal(self, faceIndex, vertexIndex, space, uvSet, binormal): 
        '''getFaceVertexBinormal(self, faceIndex, vertexIndex, space, uvSet, binormal)
Arguments:
	[in]	faceIndex = int
	[in]	vertexIndex = int
	[out]	binormal = MVector
	[in]	space = MSpace.Space
	[in]	uvSet = MString


Return the binormal vector at a given face vertex.'''
        pass

    def getBlindDataTypes(self, compType, blindDataIds): 
        '''getBlindDataTypes(self, compType, blindDataIds)
Arguments:
	[in]	compType = MFn.Type
	[out]	blindDataIds = MIntArray


Get the list of blind data ID's associated with the given component type on this mesh. (e.g. all blind data ID's present on vertex compontents)'''
        pass

    def hasBlindData(self, compType): 
        '''hasBlindData(self, compType) -> bool
Returns: true: has the specified blind data, false: does not

Arguments:
	[in]	compType = MFn.Type


Does any component of this type have any blind data. (.e. is there any vertex blind data on this mesh?)'''
        pass

    def getClosestPoint(self, toThisPoint, space, theClosestPoint, closestPolygon): 
        '''getClosestPoint(self, toThisPoint, space, theClosestPoint, closestPolygon)
Arguments:
	[in]	toThisPoint = MPoint
	[out]	theClosestPoint = MPoint
	[in]	space = MSpace.Space
	[out]	closestPolygon = int


Returns the closest point on this surface to the given point.'''
        pass

    def setFaceVertexNormals(self, normalsIn, faceList, vertexList, space): 
        '''setFaceVertexNormals(self, normalsIn, faceList, vertexList, space)
Arguments:
	[in]	normalsIn = MVectorArray
	[in]	faceList = MIntArray
	[in]	vertexList = MIntArray
	[in]	space = MSpace.Space


Set Normals for the given face/vertex pairs. Note that if there is a vertex-face mismatch anywhere in the list, this method will return an error, and not set any of the normals.'''
        pass

    def autoUniformGridParams(self): 
        '''autoUniformGridParams(self) -> MMeshIsectAccelParams


Creates a MMeshIsectAccelParams configuration object to pass to the methods  MFnMesh::closestIntersection() ,  MFnMesh::anyIntersection() , or  MFnMesh::allIntersections() . This object specifies that a uniform voxel grid structure should be used by the intersection routines to speed up their operation, and that the system should automatically determine the number of voxel cells to use based on the density of triangles in the mesh. The grid acceleration structure will be cached with the mesh, so that if the same MMeshIsectAccelParams configuration is used on the next intersect call, the acceleration structure will not need to be rebuilt.'''
        pass

    def syncObject(self): 
        '''syncObject(self)

If a non-api operation happens that many have changed the underlying Maya object wrapped by this api object, make sure that the api object references a valid maya object. In particular this call should be used if you are calling mel commands from your plugin. Note that this only applies for mesh shapes: in a plugin node where the dataMesh is being accessed directly this is not necessary.'''
        pass

    def removeFaceVertexColors(self, faceList, vertexList): 
        '''removeFaceVertexColors(self, faceList, vertexList)
Arguments:
	[in]	faceList = MIntArray
	[in]	vertexList = MIntArray


Remove colors for these face/vertex pairs'''
        pass

    def getCheckSamePointTwice(self): 
        '''getCheckSamePointTwice(self) -> bool

'''
        pass

    def lockFaceVertexNormals(self, faceList, vertexList): 
        '''lockFaceVertexNormals(self, faceList, vertexList)
Arguments:
	[in]	faceList = MIntArray
	[in]	vertexList = MIntArray


Lock Normals for these face/vertex pairs'''
        pass

    def numNormals(self): 
        '''numNormals(self) -> int
Returns: The number of per-polygon per-vertex normals


Returns the number of per-polygon per-vertex normals for this mesh. This number will correspond to the length of the normal array returned by getNormals( normalArray, space ).'''
        pass

    def getFaceVertexBinormals(self, faceIndex, space, uvSet, binormals): 
        '''getFaceVertexBinormals(self, faceIndex, space, uvSet, binormals)
Arguments:
	[in]	faceIndex = int
	[out]	binormals = MFloatVectorArray
	[in]	space = MSpace.Space
	[in]	uvSet = MString


Return all per-vertex-per-face binormals for a given face.'''
        pass

    def setVertexNormals(self, normalsIn, vertexList, space): 
        '''setVertexNormals(self, normalsIn, vertexList, space)
Arguments:
	[in]	normalsIn = MVectorArray
	[in]	vertexList = MIntArray
	[in]	space = MSpace.Space


Set Shared Normals for these vertices. The length of the normalsIn array should be same as the length of the vertexList array.'''
        pass

    def getUVSetNames(self, setNames): 
        '''getUVSetNames(self, setNames)
Arguments:
	[out]	setNames = MStringArray


Get the names of all of the uv sets on this object.'''
        pass

    def getAssociatedColorSetInstances(self, colorSetName, instances): 
        '''getAssociatedColorSetInstances(self, colorSetName, instances)
Arguments:
	[in]	colorSetName = MString
	[out]	instances = MIntArray


Get a list of the instance numbers associated with this color map. If the color map is shared across all instances, an empty array will be returned.'''
        pass

    def generateSmoothMesh(self, parentOrOwner, options): 
        '''generateSmoothMesh(self, parentOrOwner, options) -> MObject
Returns: If parentOrOwner is NULL then the transform for this surface is returned 
If parentOrOwner is a DAG object then the new surface shape is returned 
The surface geometry is returned if parentOrOwner is of type kMeshData

Arguments:
	[in]	parentOrOwner = MObject
	[in]	options = MMeshSmoothOptions


Creates a new polygonal mesh using either the Smooth Mesh Preview attributes of this mesh or a set of options specified in an  MMeshSmoothOptions  object. Unlike the  MFnMesh::create  functions, this function does not set this function set to operate on the new surface.'''
        pass

    def setPoints(self, space, vertexArray): 
        '''setPoints(self, space, vertexArray)
Arguments:
	[out]	vertexArray = MPointArray
	[in]	space = MSpace.Space


This method copies the points in the given point array to the vertices of this mesh.'''
        pass

    def getPolygonUV(self, polygonId, vertexIndex, uvSet, u, v): 
        '''getPolygonUV(self, polygonId, vertexIndex, uvSet, u, v)
Arguments:
	[in]	polygonId = int
	[in]	vertexIndex = int
	[out]	u = float
	[out]	v = float
	[in]	uvSet = MString


Get the value of the specified texture coordinate for a vertex in a polygon. Since texture coordinates (uv's) are stored per-polygon per-vertex you must specify both the polygon and the vertex that the u and v values are mapped to.'''
        pass

    def globalIntersectionAcceleratorsInfo(self): 
        '''globalIntersectionAcceleratorsInfo(self) -> MString


Retrieves a string that describes the systemwide resource usage for cached mesh intersection accelerators. The string will be formatted similar to:'''
        pass

    def getColorSetFamilyNames(self, familyNames): 
        '''getColorSetFamilyNames(self, familyNames)
Arguments:
	[out]	familyNames = MStringArray


Get the names of all of the color set families on this object. A color set family is a set of per-instance sets with the same name with each individual set applying to one or more instances. A set which is shared across all instances will be the sole member of its family.'''
        pass

    def extractFaces(self, faceList, translation): 
        '''extractFaces(self, faceList, translation)
Arguments:
	[in]	faceList = MIntArray
	[in]	translation = MFloatVector


This function detaches a set of faces from the mesh so that the resulting mesh will contain one more independant piece of geometry and leaves a hole where the faces use to be.'''
        pass

    def getBlindDataFaceVertexIndices(self, blindDataIndex, faceIndex, vertexIndex): 
        '''getBlindDataFaceVertexIndices(self, blindDataIndex, faceIndex, vertexIndex)
Arguments:
	[out]	blindDataIndex = int
	[out]	faceIndex = int
	[out]	vertexIndex = int


Get the face and vertex indices from the face-vertex blind data index.'''
        pass

    def setIsColorClamped(self, colorSet, clamped): 
        '''setIsColorClamped(self, colorSet, clamped)
Arguments:
	[in]	colorSet = MString
	[in]	clamped = bool


Set the color set to be clamped.'''
        pass

    def getColorSetsInFamily(self, familyName, setNames): 
        '''getColorSetsInFamily(self, familyName, setNames)
Arguments:
	[out]	familyName = MString
	[out]	setNames = MStringArray


Get the names of the color sets that belong to this set family. Per-instance sets will have multiple sets in a family, with each individual set applying to one or more instances. A set which is shared across all instances will be the sole member of its family and will share the same name as its family.'''
        pass

    def setBinaryBlindData(self, compID, compType, blindDataId, attrName, data, length): 
        '''setBinaryBlindData(self, compID, compType, blindDataId, attrName, data, length)
Arguments:
	[in]	compID = int
	[in]	compType = MFn.Type
	[in]	blindDataId = int
	[in]	attrName = MString
	[in]	data = char
	[in]	length = int


Set a value for a binary blind data attribute.'''
        pass

    def renameUVSet(self, origName, newName, modifier): 
        '''renameUVSet(self, origName, newName, modifier)
Arguments:
	[in]	origName = MString
	[in]	newName = MString
	[in]	modifier = MDGModifier


Renames a uv set from one name to another for this mesh. The original name must exist, and the new name cannot be the same name as one that already exists. In these cases the uv set will not be renamed.'''
        pass

    def getCreaseEdges(self, edgeIds, creaseData): 
        '''getCreaseEdges(self, edgeIds, creaseData)
Arguments:
	[out]	edgeIds = MUintArray
	[out]	creaseData = MDoubleArray


This method returns the crease edges of the mesh, and also the crease data associated with those edges.'''
        pass

class MFnMeshData:
    '''Mesh function set for dependency node data. MFnMeshData allows the creation and manipulation of Mesh data objects for use in the dependency graph.If a user written dependency node either accepts or produces Meshes, then this class is used to create data blocks into which Meshes can be constructed before being passed to other dependency graph nodes. The MDataHandle::type method will return kMesh when data of this type is present.If a node is receiving a Mesh via an input attribute, the asMesh method of MDataHandle can be used to access that input Mesh.If a node is to create a Mesh and send it via an output attribute, a new MFnMeshData must be instantiated and then the create method called to build the actual data block as an MObject. This MObject should be passed to the MFnMesh::create method as the parentOrOwner parameter so that the Mesh will be constructed inside the data block. The MDataHandle::set routine is then used to pass the data block down the connection. '''
    def __init__(self):
        pass


    def className(self): 
        '''className(self) -> char*

'''
        pass

    def create(self): 
        '''create(self) -> MObject
Returns: The new MObject 


Create a new  MObject , attach it to this instance and initialize it with a data block capable of holding a Mesh.'''
        pass

    def type(self): 
        '''type(self) -> MFn.Type

'''
        pass

class MFnMessageAttribute:
    '''Message attribute function set. Function set for message attributes. A message attribute is a dependency node attribute that does not transmit data. Message attributes only exist to formally declare relationships between nodes. By connecting two nodes via message attributes, a relationship between those nodes is expressed. Message attribute connections can be traversed in the same manner as any other connection in the dependency graph. '''
    def __init__(self):
        pass


    def className(self): 
        '''className(self) -> char*

'''
        pass

    def create(self, fullName, briefName): 
        '''create(self, fullName, briefName) -> MObject
Returns: The newly created Message attribute object.

Arguments:
	[in]	fullName = MString
	[in]	briefName = MString


Creates a Message attribute object.'''
        pass

    def type(self): 
        '''type(self) -> MFn.Type

'''
        pass

class MFnNonAmbientLight:
    '''Manage Non-ambient Light dependency Nodes. MFnNonAmbientLight facilitates modification of dependency graph nodes representing non-ambient lights. This includes area lights, linear lights, and non-extended lights. '''
    def __init__(self):
        pass


    def className(self): 
        '''className(self) -> char*

'''
        pass

    def setDecayRate(self, decay_rate): 
        '''setDecayRate(self, decay_rate)
Arguments:
	[in]	decay_rate = short


Sets the value of the "decayRate" attribute of a non-ambient light node.'''
        pass

    def type(self): 
        '''type(self) -> MFn.Type

'''
        pass

    def decayRate(self): 
        '''decayRate(self) -> short
Returns: The value of the "decayRate" attribute of the non-ambient light node.


Retrieves the value of the "decayRate" attribute of a non-ambient light node. This attribute determines the type of decay for the light.'''
        pass

class MFnNonExtendedLight:
    '''Manage Non-extended Light dependency Nodes. MFnNonExtendedLight facilitates manipulation of dependency graph nodes representing non-extended lights. This includes point lights, directional lights, and spotlights. '''
    def __init__(self):
        pass


    def setCastSoftShadows(self, cast_soft_shadows): 
        '''setCastSoftShadows(self, cast_soft_shadows)
Arguments:
	[in]	cast_soft_shadows = bool


Sets the value of the "castSoftShadows" attribute of a non-extended light node.'''
        pass

    def depthMapResolution(self): 
        '''depthMapResolution(self) -> short
Returns: The value of the "depthMapResolution" attribute of the light node.


Retrieves the value of the "depthMapResolution" attribute of a light node. This attribute determines the resolution of the depth map for this light.'''
        pass

    def setDepthMapResolution(self, depth_map_resolution): 
        '''setDepthMapResolution(self, depth_map_resolution)
Arguments:
	[in]	depth_map_resolution = short


Sets the value of the "depthMapResolution" attribute of a light node.'''
        pass

    def setUseDepthMapShadows(self, use_depth_map): 
        '''setUseDepthMapShadows(self, use_depth_map)
Arguments:
	[in]	use_depth_map = bool


Sets the value of the "useDepthMapShadows" attribute of a non-extended light node.'''
        pass

    def depthMapBias(self): 
        '''depthMapBias(self) -> float
Returns: The value of the "depthMapBias" attribute of the light node.


Retrieves the value of the "depthMapBias" attribute of a light node. This attribute represents the depth bias applied in depth map shadow computations to prevent self-shadowing artifacts.'''
        pass

    def setDepthMapBias(self, depth_map_bias): 
        '''setDepthMapBias(self, depth_map_bias)
Arguments:
	[in]	depth_map_bias = float


Sets the value of the "depthMapBias" attribute of a light node.'''
        pass

    def className(self): 
        '''className(self) -> char*

'''
        pass

    def setShadowRadius(self, shadow_radius): 
        '''setShadowRadius(self, shadow_radius)
Arguments:
	[in]	shadow_radius = float


Sets the value of the "shadowRadius" attribute of a non-extended light node.'''
        pass

    def shadowRadius(self): 
        '''shadowRadius(self) -> float
Returns: The value of the "shadowRadius" attribute of the non-extended light node.


Retrieves the value of the "shadowRadius" attribute of a non-extended light node. This attribute represents the radius of the light used when computing soft shadows. Higher radius values result in more extended soft shadows.'''
        pass

    def setDepthMapFilterSize(self, depth_map_filter_size): 
        '''setDepthMapFilterSize(self, depth_map_filter_size)
Arguments:
	[in]	depth_map_filter_size = short


Sets the value of the "depthMapFilterSize" attribute of a light node.'''
        pass

    def depthMapFilterSize(self): 
        '''depthMapFilterSize(self) -> short
Returns: The value of the "depthMapFilterSize" attribute of the light node.


Retrieves the value of the "depthMapFilterSize" attribute of a light node. This attribute determines the size of the filter used in depth map shadow computations for the light.'''
        pass

    def useDepthMapShadows(self): 
        '''useDepthMapShadows(self) -> bool
Returns: The value of the "useDepthMapShadows" attribute of the non-extended light node.


Retrieves the value of the "useDepthMapShadows" attribute of a non-extended light node. This attribute determines whether or not a depth map will be used in shadow computations for this light.'''
        pass

    def type(self): 
        '''type(self) -> MFn.Type

'''
        pass

    def castSoftShadows(self): 
        '''castSoftShadows(self) -> bool
Returns: The value of the "castSoftShadows" attribute of the non-extended light node.


Retrieves the value of the "castSoftShadows" attribute of a non-extended light node. This attribute determines whether or not the light casts soft shadows.'''
        pass

class MFnNumericAttribute:
    '''Numeric attribute function set. MFnNumericAttribute is the function set for dependency node attributes that store one, two or three untyped numeric values. A numeric attribute supports both a "hard" maximum/minimum and a soft maximum/minimum. The soft maximum/minimum are used by the Attribute Editor as the limits on its slider, but values within the hard range can be typed in the input box.As a convenience, MFnNumericAttribute will set the flags of child attributes as well when the flags of the parent attribute are set. This is important when creating a numeric pair or triplet. For example, if MFnNumericAttribute is used to create a 3 double attribute and the attribute is set to be keyable, then the three child attributes will also be marked as keyable. '''
    def __init__(self):
        pass


    def createColor(self, full, brief): 
        '''createColor(self, full, brief) -> MObject

Arguments:
	[in]	full = MString
	[in]	brief = MString


Create a new color attribute and return it as an  MObject . The names of child attributes will have "r", "g" and "b" appended to both the full and brief names.'''
        pass

    def setMin(self, min1, min2, min3): 
        '''setMin(self, min1, min2, min3)
Arguments:
	[in]	min1 = double
	[in]	min2 = double
	[in]	min3 = double


Set the minimum values for the three children (all double attributes) of this compound attribute.'''
        pass

    def hasSoftMin(self): 
        '''hasSoftMin(self) -> bool


Determine whether or not this double attribute has a soft minimum value set.'''
        pass

    def unitType(self): 
        '''unitType(self) -> MFnNumericData.Type


Return the unit type of this attribute.'''
        pass

    def getMin(self, min1, min2, min3): 
        '''getMin(self, min1, min2, min3)
Arguments:
	[out]	min1 = double
	[out]	min2 = double
	[out]	min3 = double


Return the minimum values for the three children (all double attributes) of this compound attribute.'''
        pass

    def createAddr(self, full, brief, defaultValue): 
        '''createAddr(self, full, brief, defaultValue) -> MObject

Arguments:
	[in]	full = MString
	[in]	brief = MString
	[in]	defaultValue = void


Create a new address attribute and return it as an  MObject .'''
        pass

    def getMax(self, max1, max2, max3): 
        '''getMax(self, max1, max2, max3)
Arguments:
	[out]	max1 = double
	[out]	max2 = double
	[out]	max3 = double


Return the maximum values for the three children (all double attributes) of this compound attribute.'''
        pass

    def hasSoftMax(self): 
        '''hasSoftMax(self) -> bool


Determine whether or not this double attribute has a soft maximum value set.'''
        pass

    def create(self, full, brief, child1, child2, child3): 
        '''create(self, full, brief, child1, child2, child3) -> MObject

Arguments:
	[in]	full = MString
	[in]	brief = MString
	[in]	child1 = MObject
	[in]	child2 = MObject
	[in]	child3 = MObject


Create a new numeric attribute and return it as an  MObject . This form of the create method allows the creation of compound attributes out of numeric attributes. All attributes passed in must be of the same type (eg all of type kDouble). The child1, child2, and child3 (child3 can be ommitted if only two children are desired) parameters represent two numeric attributes created previous via the other form of the create method.'''
        pass

    def setMax(self, max1, max2, max3): 
        '''setMax(self, max1, max2, max3)
Arguments:
	[in]	max1 = double
	[in]	max2 = double
	[in]	max3 = double


Set the maximum values for the three children (all double attributes) of this compound attribute.'''
        pass

    def setSoftMax(self, max): 
        '''setSoftMax(self, max)
Arguments:
	[in]	max = double


Set the soft maximum value for this double attribute.'''
        pass

    def type(self): 
        '''type(self) -> MFn.Type

'''
        pass

    def setDefault(self, def1): 
        '''setDefault(self, def1)
Arguments:
	[in]	def1 = void


Set a new default value for this address attribute.'''
        pass

    def getDefault(self, def1): 
        '''getDefault(self, def1)
Arguments:
	[out]	def1 = void


Get the default value for this address attribute.'''
        pass

    def hasMax(self): 
        '''hasMax(self) -> bool


Determine whether or not this attribute has a maximum value set.'''
        pass

    def setSoftMin(self, min): 
        '''setSoftMin(self, min)
Arguments:
	[in]	min = double


Set the soft minimum value for this double attribute.'''
        pass

    def child(self, index): 
        '''child(self, index) -> MObject

Arguments:
	[in]	index = int


Return the indicated child attribute as an  MObject . No index checking is done by this routine, so you must ensure that the index provided is valid.'''
        pass

    def getSoftMin(self, min): 
        '''getSoftMin(self, min)
Arguments:
	[out]	min = double


Return the minimum value for this double attribute.'''
        pass

    def createPoint(self, full, brief): 
        '''createPoint(self, full, brief) -> MObject

Arguments:
	[in]	full = MString
	[in]	brief = MString


Create a new point attribute and return it as an  MObject . The names of child attributes will have "x", "y" and "z" appended to both the full and brief names.'''
        pass

    def className(self): 
        '''className(self) -> char*

'''
        pass

    def getSoftMax(self, max): 
        '''getSoftMax(self, max)
Arguments:
	[out]	max = double


Return the maximum value for this double attribute.'''
        pass

    def hasMin(self): 
        '''hasMin(self) -> bool


Determine whether or not this attribute has a minimum value set.'''
        pass

class MFnNumericData:
    '''Numeric data function set. MFnNumericData allows the creation and manipulation of numeric data objects for use in the dependency graph. Normally, data objects are not required for the transmission of numeric data. The graph supports numeric types directly (see the methods of MDataHandle).Numeric data objects are useful if you have an attribute that accepts generic data. A generic attribute can accept multiple types of data, so you cannot hardwire it to accept a specific type of numeric data. So, generic attributes can only accept numeric data in the form of actual data objects.This function set only supports pairs and triples of numeric data. '''
    def __init__(self):
        pass


    def getData2Int(self, val1, val2): 
        '''getData2Int(self, val1, val2)
Arguments:
	[out]	val1 = int
	[out]	val2 = int


Gets the stored value of this data object as a pair of int integers. The data object must have been created as a pair of int integers for this to succeed.'''
        pass

    def numericType(self): 
        '''numericType(self) -> MFnNumericData.Type
Returns: Type of data


Returns the type of the numeric data object.'''
        pass

    def setData4Double(self, val1, val2, val3, val4): 
        '''setData4Double(self, val1, val2, val3, val4)
Arguments:
	[in]	val1 = double
	[in]	val2 = double
	[in]	val3 = double
	[in]	val4 = double


Sets the stored value of this data object as a quadruple of doubles. The data object must have been created as a quadruple of doubles for this to succeed.'''
        pass

    def setData2Int(self, val1, val2): 
        '''setData2Int(self, val1, val2)
Arguments:
	[in]	val1 = int
	[in]	val2 = int


Sets the stored value of this data object as a pair of int integers. The data object must have been created as a pair of int integers for this to succeed.'''
        pass

    def setData3Short(self, val1, val2, val3): 
        '''setData3Short(self, val1, val2, val3)
Arguments:
	[in]	val1 = short
	[in]	val2 = short
	[in]	val3 = short


Sets the stored value of this data object as a triple of short integers. The data object must have been created as a triple of short integers for this to succeed.'''
        pass

    def k3Double(self):
        '''This is an enum of Type.
Description: Three doubles.
Value: 15'''
        pass

    def k3Long(self):
        '''This is an enum of Type.
Description: Three longs. Same as 3 ints since "long" is not platform-consistent.
Value: 9'''
        pass

    def kByte(self):
        '''This is an enum of Type.
Description: One byte.
Value: 2'''
        pass

    def kDouble(self):
        '''This is an enum of Type.
Description: One double.
Value: 13'''
        pass

    def k3Int(self):
        '''This is an enum of Type.
Description: Three ints.
Value: 9'''
        pass

    def k4Double(self):
        '''This is an enum of Type.
Description: Four doubles.
Value: 16'''
        pass

    def kBoolean(self):
        '''This is an enum of Type.
Description: Boolean.
Value: 1'''
        pass

    def kShort(self):
        '''This is an enum of Type.
Description: One short.
Value: 4'''
        pass

    def k2Float(self):
        '''This is an enum of Type.
Description: Two floats.
Value: 11'''
        pass

    def kFloat(self):
        '''This is an enum of Type.
Description: One float.
Value: 10'''
        pass

    def kLong(self):
        '''This is an enum of Type.
Description: One long. Same as int since "long" is not platform-consistent.
Value: 7'''
        pass

    def k3Float(self):
        '''This is an enum of Type.
Description: Three floats.
Value: 12'''
        pass

    def k3Short(self):
        '''This is an enum of Type.
Description: Three shorts.
Value: 6'''
        pass

    def k2Short(self):
        '''This is an enum of Type.
Description: Two shorts.
Value: 5'''
        pass

    def kLast(self):
        '''This is an enum of Type.
Description: Last value. Does not represent a real type, but can be used to loop on all possible types.
Value: 18'''
        pass

    def kInvalid(self):
        '''This is an enum of Type.
Description: Invalid data.
Value: 0'''
        pass

    def k2Int(self):
        '''This is an enum of Type.
Description: Two ints.
Value: 8'''
        pass

    def kInt(self):
        '''This is an enum of Type.
Description: One int.
Value: 7'''
        pass

    def kAddr(self):
        '''This is an enum of Type.
Description: An address.
Value: 17'''
        pass

    def k2Double(self):
        '''This is an enum of Type.
Description: Two doubles.
Value: 14'''
        pass

    def kChar(self):
        '''This is an enum of Type.
Description: One character.
Value: 3'''
        pass

    def k2Long(self):
        '''This is an enum of Type.
Description: Two longs. Same as 2 ints since "long" is not platform-consistent.
Value: 8'''
        pass

    class Type:
        '''Non-functional class.  Values for this enum:
        k3Double
        k3Long
        kByte
        kDouble
        k3Int
        k4Double
        kBoolean
        kShort
        k2Float
        kFloat
        kLong
        k3Float
        k3Short
        k2Short
        kLast
        kInvalid
        k2Int
        kInt
        kAddr
        k2Double
        kChar
        k2Long
'''
        def __init__(self):
            pass

    def setData2Float(self, val1, val2): 
        '''setData2Float(self, val1, val2)
Arguments:
	[in]	val1 = float
	[in]	val2 = float


Sets the stored value of this data object as a pair of floats. The data object must have been created as a pair of floats for this to succeed.'''
        pass

    def create(self, dataType): 
        '''create(self, dataType) -> MObject
Returns: A pointer to the new object

Arguments:
	[in]	dataType = MFnNumericData.Type


Creates a new data object of the given type. Only pair and triples of numeric data may be created (eg k3Float).'''
        pass

    def getData2Double(self, val1, val2): 
        '''getData2Double(self, val1, val2)
Arguments:
	[out]	val1 = double
	[out]	val2 = double


Gets the stored value of this data object as a pair of doubles. The data object must have been created as a pair of doubles for this to succeed.'''
        pass

    def type(self): 
        '''type(self) -> MFn.Type

'''
        pass

    def setData2Double(self, val1, val2): 
        '''setData2Double(self, val1, val2)
Arguments:
	[in]	val1 = double
	[in]	val2 = double


Sets the stored value of this data object as a pair of doubles. The data object must have been created as a pair of doubles for this to succeed.'''
        pass

    def getData4Double(self, val1, val2, val3, val4): 
        '''getData4Double(self, val1, val2, val3, val4)
Arguments:
	[out]	val1 = double
	[out]	val2 = double
	[out]	val3 = double
	[out]	val4 = double


Gets the stored value of this data object as a quadruple of doubles. The data object must have been created as a quadruple of doubles for this to succeed.'''
        pass

    def getData3Float(self, val1, val2, val3): 
        '''getData3Float(self, val1, val2, val3)
Arguments:
	[out]	val1 = float
	[out]	val2 = float
	[out]	val3 = float


Gets the stored value of this data object as a triple of floats. The data object must have been created as a triple of floats for this to succeed.'''
        pass

    def getData2Float(self, val1, val2): 
        '''getData2Float(self, val1, val2)
Arguments:
	[out]	val1 = float
	[out]	val2 = float


Gets the stored value of this data object as a pair of floats. The data object must have been created as a pair of floats for this to succeed.'''
        pass

    def setData3Int(self, val1, val2, val3): 
        '''setData3Int(self, val1, val2, val3)
Arguments:
	[in]	val1 = int
	[in]	val2 = int
	[in]	val3 = int


Sets the stored value of this data object as a triple of int integers. The data object must have been created as a triple of int integers for this to succeed.'''
        pass

    def getData3Int(self, val1, val2, val3): 
        '''getData3Int(self, val1, val2, val3)
Arguments:
	[out]	val1 = int
	[out]	val2 = int
	[out]	val3 = int


Gets the stored value of this data object as a triple of int integers. The data object must have been created as a triple of int integers for this to succeed.'''
        pass

    def setData3Double(self, val1, val2, val3): 
        '''setData3Double(self, val1, val2, val3)
Arguments:
	[in]	val1 = double
	[in]	val2 = double
	[in]	val3 = double


Sets the stored value of this data object as a triple of doubles. The data object must have been created as a triple of doubles for this to succeed.'''
        pass

    def getData3Double(self, val1, val2, val3): 
        '''getData3Double(self, val1, val2, val3)
Arguments:
	[out]	val1 = double
	[out]	val2 = double
	[out]	val3 = double


Gets the stored value of this data object as a triple of doubles. The data object must have been created as a triple of doubles for this to succeed.'''
        pass

    def getData2Short(self, val1, val2): 
        '''getData2Short(self, val1, val2)
Arguments:
	[out]	val1 = short
	[out]	val2 = short


Gets the stored value of this data object as a pair of short integers. The data object must have been created as a pair of short integers for this to succeed.'''
        pass

    def setData3Float(self, val1, val2, val3): 
        '''setData3Float(self, val1, val2, val3)
Arguments:
	[in]	val1 = float
	[in]	val2 = float
	[in]	val3 = float


Sets the stored value of this data object as a triple of floats. The data object must have been created as a triple of floats for this to succeed.'''
        pass

    def className(self): 
        '''className(self) -> char*

'''
        pass

    def setData2Short(self, val1, val2): 
        '''setData2Short(self, val1, val2)
Arguments:
	[in]	val1 = short
	[in]	val2 = short


Sets the stored value of this data object as a pair of short integers. The data object must have been created as a pair of short integers for this to succeed.'''
        pass

    def getData3Short(self, val1, val2, val3): 
        '''getData3Short(self, val1, val2, val3)
Arguments:
	[out]	val1 = short
	[out]	val2 = short
	[out]	val3 = short


Gets the stored value of this data object as a triple of short integers. The data object must have been created as a pair of short integers for this to succeed.'''
        pass

class MFnNurbsCurve:
    '''NURBS curve function set. This is the function set for NURBS (Non-Uniform Rational B-Spline) curves.The shape of a NURBS curve is defined by an array of CVs (control vertices), an array of knot values, a degree, and a form. There are 3 possible "forms" for the curve: ,  and .The  and  forms are quite similar, and in fact a closed curve will become an open curve if either the first or last CV is moved so that they are no longer coincident. To create an open or closed curve of degree N with M spans, you must provide M+N CVs. This implies that for a degree N curve, you must specify at least N+1 CVs to get a curve with a single span.The number of knots required for a curve is M + 2N - 1. If you want the curve to start exactly at the first CV and end exactly at the last CV, then the knot vector must be structured to have degree N "multiplicity" at the beginning and end. This means that the first N knots must be identical, and the last N knots must be identical.A  curve is a special case of a closed curve. Instead of having just the first and last CVs coincident, the last N CVs in the curve must overlap the first N CVs. This results in a curve with no tangent break at the seam where the ends meet. The last N CVs in a periodic curve are permanently bound to the first N CVs, and Maya will not allow those last N CVs to be repositioned. If one or more of the first N CVs of the curve are repositioned, the overlapping CV's will remain bound, and will also be moved.In order to create a periodic curve, you must specify at least 2N+1 CVs, so that that last N can overlap the first N and you still have 1 non-overlapping CV left. The number of CVs required to create a periodic curve is still N+M (with a lower limit of 2N+1), but you must ensure that the positions of the last N CVs are identical to the positions of the first N.You still need M + 2N - 1 knots for a periodic curve, but the knot values required are more restrictive than for open or closed curves because of the overlap at the ends, The difference between the first N pairs of knots values should be equal to the difference between the last N pairs. Additionally there can be no knot multiplicity at the ends of the curve, because that would compromise the tangent continuity property. So an example knot sequence could begin with knots at { -(N-2), -(N-1), ... , 0}.Note that some third party applications use a different format for knots, where the number of knots required for a curve is M+2N+1 rather than M+2N-1 as used in Maya. Both knot representations are equivalent mathematically. To convert from one of these external representations into the Maya representation, simply omit the first and last knots from the external representation when creating the Maya representation. To convert from the Maya representation into the external representation, add two new knots at the beginning and end of the Maya knot sequence. The value of these new knots depends on the existing knot sequence. For a knot sequence with multiple end knots, simply duplicate the existing first and last knots once more, for example:Maya representation: {0,0,0,...,N,N,N}  External representation: {0,0,0,0,...,N,N,N,N} For a knot sequence with uniform end knots, create the new knots offset at an interval equal to the existing first and last knot intervals, for example:Maya representation: {0,1,2,...,N,N+1,N+2}  External representation: {-1,0,1,2,...,N,N+1,N+2,N+3} '''
    def __init__(self):
        pass


    def getCVs(self, space, array): 
        '''getCVs(self, space, array)
Arguments:
	[out]	array = MPointArray
	[in]	space = MSpace.Space


Get the positions of the CVs of this curve. The returned group can be accessed via the  MPointArray  class. Any modifications to these CVs will not affect this curve.  setCVs  should be called to modify the original curve.  updateCurve  should be called to cause the curve to redraw itself.'''
        pass

    def numSpans(self): 
        '''numSpans(self) -> int
Returns: The number of spans for this curve.


Return the number of spans for this curve. If the number of spans cannot be determined then 0 is returned.'''
        pass

    def getParamAtPoint(self, atThisPoint, tolerance, space, param): 
        '''getParamAtPoint(self, atThisPoint, tolerance, space, param)
Arguments:
	[in]	atThisPoint = MPoint
	[out]	param = double
	[in]	tolerance = double
	[in]	space = MSpace.Space


This method retrieves the parameter value corresponding to the given point on the curve.'''
        pass

    def setKnots(self, array, startIndex, endIndex): 
        '''setKnots(self, array, startIndex, endIndex)
Arguments:
	[in]	array = MDoubleArray
	[in]	startIndex = int
	[in]	endIndex = int


This method is used to set the values of a contiguous group of knots of the curve. The range of knots to set is specified using the start and end index. The knots of index startIndex to endIndex inclusive will be set using the value in the double array.'''
        pass

    def isPlanar(self, planeNormal): 
        '''isPlanar(self, planeNormal) -> bool
Returns: Status code

Arguments:
	[in]	planeNormal = MVector


This method determines if this curve is a planar curve. If planeNormal is non-NULL then the normal to the plane containing this curve is returned in this location.'''
        pass

    def cv(self, index): 
        '''cv(self, index) -> MObject
Returns: A handle to the CVs requested

Arguments:
	[out]	index = int


Get a direct access handle to the CV at the specified index. The CV iterator class  MItCurveCV  must be used to access the returned CV.'''
        pass

    def removeKnot(self, atThisParam, removeAll): 
        '''removeKnot(self, atThisParam, removeAll)
Arguments:
	[in]	atThisParam = double
	[in]	removeAll = bool


Remove knot(s) from this curve. If  removeAll  is  true  then all of the knots except for the knot at the given parameter value will be removed. If  removeAll  is  false  then only the knot at the given parameter value will be removed.'''
        pass

    def hasHistoryOnCreate(self): 
        '''hasHistoryOnCreate(self) -> bool


This method determines if the shape was created with history.'''
        pass

    def form(self): 
        '''form(self) -> MFnNurbsCurve.Form
Returns: MFnNurbsCurve::kOpen 
MFnNurbsCurve::kClosed 
MFnNurbsCurve::kPeriodic


This method returns the form of the curve. The curve can be open, closed, or periodic.'''
        pass

    def kClosed(self):
        '''This is an enum of Form.
Description: Endpoints are coincident.
Value: 2'''
        pass

    def kOpen(self):
        '''This is an enum of Form.
Description: Ends are independent.
Value: 1'''
        pass

    def kInvalid(self):
        '''This is an enum of Form.
Description: 
Value: 0'''
        pass

    def kLast(self):
        '''This is an enum of Form.
Description: 
Value: 4'''
        pass

    def kPeriodic(self):
        '''This is an enum of Form.
Description: Ends overlap such that there is no break in tangency.
Value: 3'''
        pass

    class Form:
        '''Non-functional class.  Values for this enum:
        kClosed
        kOpen
        kInvalid
        kLast
        kPeriodic
'''
        def __init__(self):
            pass

    def area(self, tolerance): 
        '''area(self, tolerance) -> double
Returns: Status code

Arguments:
	[in]	tolerance = double


This method returns the area bounded by this curve. The curve must be closed and planar.'''
        pass

    def setCVs(self, array, space): 
        '''setCVs(self, array, space)
Arguments:
	[in]	array = MPointArray
	[in]	space = MSpace.Space


Set the CVs for this curve to the given points.'''
        pass

    def create(self, sources, parentOrOwner): 
        '''create(self, sources, parentOrOwner) -> MObject
Returns: If parentOrOwner is NULL then the transform for this curve is returned 
If parentOrOwner is a DAG object then the curve shape is returned 
The curve geometry is returned if parentOrOwner is of type kNurbsCurveData

Arguments:
	[in]	sources = MObjectArray
	[in]	parentOrOwner = MObject


This method creates a single curve that represents all the curves in the  MObjectArray . The method assumes the curves in the sources are good for building a single curve:  
 they are in the same direction,  
 they are not intersective to themselvies or eath other,  
 there are no gaps between the points at the ends.  
 the order of the curves in the array are followed, i.e. the result curve starts from  sources[0] . 
 
It is good enough to be C0 continouns (tangent breaks are okay).'''
        pass

    def updateCurve(self): 
        '''updateCurve(self)

This method signals that this curve has changed and needs to be recalculated.'''
        pass

    def isPointOnCurve(self, point, tolerance, space): 
        '''isPointOnCurve(self, point, tolerance, space) -> bool
Returns: true if the given point is on the curve, false otherwise.

Arguments:
	[in]	point = MPoint
	[in]	tolerance = double
	[in]	space = MSpace.Space


Determines whether the given point is on this curve.'''
        pass

    def findParamFromLength(self, partLength): 
        '''findParamFromLength(self, partLength) -> double
Returns: The parameter value corrisponding to the given length. If a parameter cannot be found for the given length then the parameter for the end point of the curve is returned.

Arguments:
	[in]	partLength = double


Given the length along the curve, find the parameter value that corresponds to it. If the parameter value cannot be found for the given length then ReturnStatus is set to kInvalidParameter and the parameter for the end point of the curve is returned.'''
        pass

    def getPointAtParam(self, param, space, point): 
        '''getPointAtParam(self, param, space, point)
Arguments:
	[in]	param = double
	[out]	point = MPoint
	[in]	space = MSpace.Space


Returns the point in space that is at the given parameter value of the curve. If the parameter value does not give a valid point on the curve, then  MS::kInvalidParameter  is returned.'''
        pass

    def setKnot(self, index, param): 
        '''setKnot(self, index, param)
Arguments:
	[in]	index = int
	[in]	param = double


Set the given knot's parameter value. Knot indices range from  0  to  numKnots()  - 1 .'''
        pass

    def type(self): 
        '''type(self) -> MFn.Type

'''
        pass

    def getCV(self, index, space, pt): 
        '''getCV(self, index, space, pt)
Arguments:
	[in]	index = int
	[out]	pt = MPoint
	[in]	space = MSpace.Space


Get the CV at the given index.'''
        pass

    def closestPoint(self, toThisPoint, paramAsStart, param, tolerance, space): 
        '''closestPoint(self, toThisPoint, paramAsStart, param, tolerance, space) -> MPoint
Returns: The point on the curve closest to the given point.

Arguments:
	[in]	toThisPoint = MPoint
	[in]	paramAsStart = bool
	[in]	param = double
	[in]	tolerance = double
	[in]	space = MSpace.Space


This method determines the closest point on the curve to the given point. Performance can be greatly increased by supplying a starting parameter value that is reasonably close to the final point.'''
        pass

    def isParamOnCurve(self, param): 
        '''isParamOnCurve(self, param) -> bool
Returns: true The parameter is on this curve. 
false Parameter is NOT on this curve.

Arguments:
	[in]	param = double


Determines whether the specified parameter value is within the bounds of the knot vector of this curve'''
        pass

    def degree(self): 
        '''degree(self) -> int
Returns: The degree of this curve.


Return the degree of this curve. If the degree cannot be determined then 0 is returned.'''
        pass

    def normal(self, param, space): 
        '''normal(self, param, space) -> MVector
Returns: The normal vector for the given parameter

Arguments:
	[in]	param = double
	[in]	space = MSpace.Space


This method returns the normal at the given parameter value on the curve. For degree 1 curves the normal is the vector at right angles to the curve that lies in the average plane of the curve. For higher degrees the normal is defined by the local curvature at param.'''
        pass

    def tangent(self, param, space): 
        '''tangent(self, param, space) -> MVector
Returns: The tangent vector for the given parameter

Arguments:
	[in]	param = double
	[in]	space = MSpace.Space


This method returns the tangent at the given parameter value on the curve. The resulting tangent vector is normalized.'''
        pass

    def knot(self, index): 
        '''knot(self, index) -> double
Returns: The parameter value for the knot at index.

Arguments:
	[in]	index = int


Get the parameter value of the specified knot for this curve. Knot indices range from  0  to  numKnots()  - 1'''
        pass

    def getKnotDomain(self, start, end): 
        '''getKnotDomain(self, start, end)
Arguments:
	[out]	start = double
	[out]	end = double


Return the range corresponding to the maximum and minimum parameter values for this curve.'''
        pass

    def numCVs(self): 
        '''numCVs(self) -> int
Returns: The number of CVs for this curve.


Return the number of CVs for this curve. If the number of CVs cannot be determined then 0 is returned.'''
        pass

    def setCV(self, index, pt, space): 
        '''setCV(self, index, pt, space)
Arguments:
	[in]	index = int
	[in]	pt = MPoint
	[in]	space = MSpace.Space


Set the CV at the given index to the given point. The method  updateCurve  should be called to trigger changes in the curve.'''
        pass

    def copy(self, source, parentOrOwner): 
        '''copy(self, source, parentOrOwner) -> MObject
Returns: If parentOrOwner is NULL then the transform for this curve is returned 
If parentOrOwner is a DAG object then the curve shape is returned 
The curve geometry is returned if parentOrOwner is of type kNurbsCurveData

Arguments:
	[in]	source = MObject
	[in]	parentOrOwner = MObject


This method creates a copy of a nurbs curve.'''
        pass

    def numKnots(self): 
        '''numKnots(self) -> int
Returns: The number of knots for this curve.


Return the number of knots for this curve. If the number of knots cannot be determined then 0 is returned.'''
        pass

    def reverse(self, constructionHistory): 
        '''reverse(self, constructionHistory)
Arguments:
	[in]	constructionHistory = bool


This method reverse the curve direction.'''
        pass

    def cvs(self, startIndex, endIndex): 
        '''cvs(self, startIndex, endIndex) -> MObject
Returns: An MObject providing direct-access to the specified CVs

Arguments:
	[in]	startIndex = int
	[in]	endIndex = int


This method is used to directly access a contiguous group of CVs. The returned group can be accessed via the  MItCurveCV  class. Any modifications to these CVs will affect this curve.  updateCurve  should be called to cause the curve to redraw itself.'''
        pass

    def className(self): 
        '''className(self) -> char*

'''
        pass

    def getKnots(self, array): 
        '''getKnots(self, array)
Arguments:
	[out]	array = MDoubleArray


This method retrieves a copy of the knot array for this curve.'''
        pass

    def length(self, tolerance): 
        '''length(self, tolerance) -> double
Returns: Status code

Arguments:
	[in]	tolerance = double


Return the arc length of this curve or 0.0 if it cannot be computed.'''
        pass

    def getDerivativesAtParm(self, param, space, pos, dU, dUU): 
        '''getDerivativesAtParm(self, param, space, pos, dU, dUU)
Arguments:
	[in]	param = double
	[out]	pos = MPoint
	[out]	dU = MVector
	[in]	space = MSpace.Space
	[out]	dUU = MVector


Evaluate the surface at the given parameter returning the position, first derivative and optionally the seecond derivative. Derivatives are not normalized.'''
        pass

    def makeMultipleEndKnots(self): 
        '''makeMultipleEndKnots(self)

This method gives end knots full multiplicity. This ensures the end points of the curve interpolate the first and last CVs. It can also be used to convert a periodic curve to a closed curve.'''
        pass

    def distanceToPoint(self, pt, space): 
        '''distanceToPoint(self, pt, space) -> double
Returns: Status code

Arguments:
	[in]	pt = MPoint
	[in]	space = MSpace.Space


This method determines the distance from the given point to closest point on the curve.'''
        pass

    def createWithEditPoints(self, editPoints, degree, form, create2D, createRational, uniformParam, parentOrOwner): 
        '''createWithEditPoints(self, editPoints, degree, form, create2D, createRational, uniformParam, parentOrOwner) -> MObject
Returns: If parentOrOwner is NULL then the transform for this curve is returned 
If parentOrOwner is a DAG object then the curve shape is returned 
The curve geometry is returned if parentOrOwner is of type kNurbsCurveData

Arguments:
	[in]	editPoints = MPointArray
	[in]	degree = int
	[in]	form = MFnNurbsCurve.Form
	[in]	create2D = bool
	[in]	createRational = bool
	[in]	uniformParam = bool
	[in]	parentOrOwner = MObject


This method creates a nurbs curve from the given edit points and sets this function set to operate on the new curve.'''
        pass

class MFnNurbsCurveData:
    '''Nurbs Curve function set for dependency node data. MFnNurbsCurveData allows the creation and manipulation of NurbsCurve data objects for use in the dependency graph.If a user written dependency node either accepts or produces Nurbs Curves, then this class is used to create data blocks into which Nurbs Curves can be constructed before being passed to other dependency graph nodes. The MDataHandle::type method will return kNurbsCurve when data of this type is present.If a node is receiving a Nurbs Curve via an input attribute, the asNurbsCurve method of MDataHandle can be used to access that input Nurbs Curve.If a node is to create a Nurbs Curve and send it via an output attribute, a new MFnNurbsCurveData must be instantiated and then the create method called to build the actual data block as an MObject. This MObject should be passed to the MFnNurbsCurve::create method as the parentOrOwner parameter so that the Nurbs Curve will be constructed inside the data block. The MDataHandle::set routine is then used to pass the data block down the connection. '''
    def __init__(self):
        pass


    def className(self): 
        '''className(self) -> char*

'''
        pass

    def create(self): 
        '''create(self) -> MObject
Returns: The new MObject 


Create a new  MObject , attach it to this instance and initialize it with a data block capable of holding a Nurbs Curve.'''
        pass

    def type(self): 
        '''type(self) -> MFn.Type

'''
        pass

class MFnNurbsSurface:
    '''NURBS surface function set. This is the function set for NURBS (Non-Uniform Rational B-spline) surfaces.The shape of a NURBS surface is defined by an array of CVs (control vertices), an array of knot values in the U direction and an array of knot values in the V direction, a degree in U and in V, and a form in U and in V.The U and V knot vectors for NURBS surfaces are of size  and . Note: spans = numCVs - degree.There are 3 possible "forms" for the surface in the U and V directions: ,  and . These forms are described below. Note that the descriptions below apply to both the U and V directions.The  and  forms are quite similar, and in fact a closed surface will become and open surface if either the first or last CV is moved so that they are no longer coincident. To create an open or closed surface, of degree N, with M spans, you must provide M+N CVs. This implies that for a degree N surface, you must specify at least N+1 CVs to get a surface with a single span.The number of knots required for the surface is M + 2N - 1. If you want the surface to start exactly at the first CV and end exactly at the last CV, then the knot vector must be structured to have degree N "multiplicity" at the beginning and end. This means that the first N knots must be identical, and the last N knots must be identical.A  surface is a special case of a closed surface. Instead of having just the first and last CVs coincident, the last N CVs in the surface, where N is equal to the degree, overlap the first N CVs. This results in a surface with no tangent break where the ends meet. The last N CVs in a periodic surface are permanently bound to the first N CVs, and Maya will not allow those last N CVs to be repositioned. If one or more of the first N CVs of the surface are repositioned, the overlapping CV's will remain bound, and will also be moved.In order to create a periodic surface, you must specify at least 2N+1 CVs, so that that last N can overlap the first N and you still have 1 non-overlapping CV left. The number of CVs required to create a periodic surface is still N+M (with a lower limit of 2N+1), but you must ensure that the positions of the last N CVs are identical to the positions of the first N.You still need M + 2N - 1 knots for a periodic surface, but the knot values required are more restrictive than for open or closed surfaces because of the overlap of the last N CVs. The first N knots should be specified at the beginning of the knot array as values { -(N-1), -(N-2), ... 0 } in order to implement the overlap. Additionally there can be no knot multiplicity at the end of the surface, because that would compromise the tangent continuity property.Note that some third party applications use a different format for knots, where the number of knots required for a surface is M+2N+1 rather than M+2N-1 as used in Maya. Both knot representations are equivalent mathematically. To convert from one of these external representations into the Maya representation, simply omit the first and last knots from the external representation when creating the Maya representation. To convert from the Maya representation into the external representation, add two new knots at the beginning and end of the Maya knot sequence. The value of these new knots depends on the existing knot sequence. For a knot sequence with multiple end knots, simply duplicate the existing first and last knots once more, for example:Maya representation: {0,0,0,...,N,N,N} External representation: {0,0,0,0,...,N,N,N,N}For a knot sequence with uniform end knots, create the new knots offset at an interval equal to the existing first and last knot intervals, for example:Maya representation: {0,1,2,...,N,N+1,N+2} External representation: {-1,0,1,2,...,N,N+1,N+2,N+3} '''
    def __init__(self):
        pass


    def trim(self, locatorU, locatorV, constructionHistory): 
        '''trim(self, locatorU, locatorV, constructionHistory)
Arguments:
	[in]	locatorU = MDoubleArray
	[in]	locatorV = MDoubleArray
	[in]	constructionHistory = bool


Trim this surface to its curves on surface. Regions which are kept are specified by passing in two arrays of u,v parameters.'''
        pass

    def getAssignedUVs(self, uvCounts, uvIds): 
        '''getAssignedUVs(self, uvCounts, uvIds)
Arguments:
	[out]	uvCounts = MIntArray
	[out]	uvIds = MIntArray


Get assigned UVs. This method finds all texture coordinates for the surface that have been mapped, and returns them in the same format as assignUVs. The setUV/setUVs method is used to create the texture coordinate table for the surface and this method is used to map those values to each patch on a per-corner basis.'''
        pass

    def getCVs(self, space, array): 
        '''getCVs(self, space, array)
Arguments:
	[out]	array = MPointArray
	[in]	space = MSpace.Space


Get the positions of the CVs on this surface. The returned group can be accessed via the  MPointArray  class.  numCVsInU()  *  numCVsInV()  points will be returned. Converting from uIndex, vIndex is done by "index = numCVsInV() * uIndex + vIndex".'''
        pass

    def getKnotsInV(self, array): 
        '''getKnotsInV(self, array)
Arguments:
	[out]	array = MDoubleArray


Get the knots along the V direction for this surface.'''
        pass

    def getKnotsInU(self, array): 
        '''getKnotsInU(self, array)
Arguments:
	[out]	array = MDoubleArray


Get the knots along the U direction for this surface.'''
        pass

    def numBoundaries(self, region): 
        '''numBoundaries(self, region) -> int
Returns: The number of boundaries for the specified region

Arguments:
	[in]	region = int


Returns the number of boudaries for the specified region. The surface must be a trimmed surface.'''
        pass

    def setKnotsInV(self, array, startIndex, endIndex): 
        '''setKnotsInV(self, array, startIndex, endIndex)
Arguments:
	[in]	array = MDoubleArray
	[in]	startIndex = int
	[in]	endIndex = int


Set the specified V knot values for this surface.'''
        pass

    def setKnotsInU(self, array, startIndex, endIndex): 
        '''setKnotsInU(self, array, startIndex, endIndex)
Arguments:
	[in]	array = MDoubleArray
	[in]	startIndex = int
	[in]	endIndex = int


Set the specified U knot values for this surface.'''
        pass

    def getParamAtPoint(self, atThisPoint, ignoreTrimBoundaries, space, tolerance, paramU, paramV): 
        '''getParamAtPoint(self, atThisPoint, ignoreTrimBoundaries, space, tolerance, paramU, paramV)
Arguments:
	[in]	atThisPoint = MPoint
	[out]	paramU = double
	[out]	paramV = double
	[in]	ignoreTrimBoundaries = bool
	[in]	space = MSpace.Space
	[in]	tolerance = double


Get the parameter value corresponding to the given point on the surface (or underlying surface).'''
        pass

    def isFoldedOnBispan(self): 
        '''isFoldedOnBispan(self) -> bool


Evaluate the surface to determine if it contains any folds or creases. The entire surface including trimmed regions is examined. This function will only check for folds on bispan boundaries and thus will not catch all cases.'''
        pass

    def degreeV(self): 
        '''degreeV(self) -> int
Returns: The degree in V


Returns the degree of the surface in V (1 - 3).'''
        pass

    def degreeU(self): 
        '''degreeU(self) -> int
Returns: The degree in U


Returns the degree of the surface in U (1 - 3).'''
        pass

    def isTrimmedSurface(self): 
        '''isTrimmedSurface(self) -> bool


This method determines if this surface is a trimmed surface.'''
        pass

    def numSpansInU(self): 
        '''numSpansInU(self) -> int
Returns: The number of spans in U


Returns the number of spans in the u direction.'''
        pass

    def getTangents(self, paramInU, paramInV, space, vectorInU, vectorInV): 
        '''getTangents(self, paramInU, paramInV, space, vectorInU, vectorInV)
Arguments:
	[in]	paramInU = double
	[in]	paramInV = double
	[out]	vectorInU = MVector
	[out]	vectorInV = MVector
	[in]	space = MSpace.Space


Retrieve the tangents in the U and V directions at the given parameter value on the surface. The returned tangent vectors are normalized.'''
        pass

    def numSpansInV(self): 
        '''numSpansInV(self) -> int
Returns: The number of spans in V


Returns the number of spans in the v direction.'''
        pass

    def formInV(self): 
        '''formInV(self) -> MFnNurbsSurface.Form
Returns: The form of this surface in V


Return the form of this surface in V. Form can be kOpen, kClosed, kPeriodic, or kUnknownForm.'''
        pass

    def numCVsInU(self): 
        '''numCVsInU(self) -> int
Returns: The number of CVs in U


Returns the number of CVs in the U direction (degree + spans).'''
        pass

    def numCVsInV(self): 
        '''numCVsInV(self) -> int
Returns: The number of CVs in V


Returns the number of CVs in the V direction (degree + spans).'''
        pass

    def formInU(self): 
        '''formInU(self) -> MFnNurbsSurface.Form
Returns: The form of this surface in U


Return the form of this surface in U. Form can be kOpen, kClosed, kPeriodic, or kUnknownForm.'''
        pass

    def cv(self, indexU, indexV): 
        '''cv(self, indexU, indexV) -> MObject
Returns: The cv component

Arguments:
	[in]	indexU = int
	[in]	indexV = int


Returns a component for the specified CV.'''
        pass

    def numUVs(self): 
        '''numUVs(self) -> int
Returns: The number of texture coordinates


Returns the number of texture (uv) coordinates for this surface. The uv's are stored in a list which is referenced by patches requiring textures on a per-patch per-patchCorner basis. This method returns the number of elements in this list.'''
        pass

    def setKnotInV(self, index, param): 
        '''setKnotInV(self, index, param)
Arguments:
	[in]	index = int
	[in]	param = double


Set the value of the given existing knot at the specified V index. Knots are indexed from 0 to numKnots-1. Note that this routine does not insert a new knot, it simply changes the value of a knot that already exists.'''
        pass

    def projectCurve(self, curve, direction, constructionHistory): 
        '''projectCurve(self, curve, direction, constructionHistory)
Arguments:
	[in]	curve = MDagPath
	[in]	direction = MVector
	[in]	constructionHistory = bool


Project the given curve onto this surface creating a curve on surface. Projection will be done using the surface normals unless a direction vector to project along is given.'''
        pass

    def hasHistoryOnCreate(self): 
        '''hasHistoryOnCreate(self) -> bool


This method determines if the shape was created with history.'''
        pass

    def numPatchesInV(self): 
        '''numPatchesInV(self) -> int
Returns: The number of non-zero patches along v, in this surface.


Returns the number of non-zero patches along v, in this surface.'''
        pass

    def setKnotInU(self, index, param): 
        '''setKnotInU(self, index, param)
Arguments:
	[in]	index = int
	[out]	param = double


Set the value of the given existing knot at the specified U index. Knots are indexed from 0 to numKnots-1. Note that this routine does not insert a new knot, it simply changes the value of a knot that already exists.'''
        pass

    def kClosed(self):
        '''This is an enum of Form.
Description: Edges are coincident.
Value: 2'''
        pass

    def kOpen(self):
        '''This is an enum of Form.
Description: Edges are independent.
Value: 1'''
        pass

    def kInvalid(self):
        '''This is an enum of Form.
Description: 
Value: 0'''
        pass

    def kLast(self):
        '''This is an enum of Form.
Description: 
Value: 4'''
        pass

    def kPeriodic(self):
        '''This is an enum of Form.
Description: Edges overlap such that there is no break in tangency.
Value: 3'''
        pass

    class Form:
        '''Non-functional class.  Values for this enum:
        kClosed
        kOpen
        kInvalid
        kLast
        kPeriodic
'''
        def __init__(self):
            pass

    def area(self, space, tolerance): 
        '''area(self, space, tolerance) -> double
Returns: The area of this surface

Arguments:
	[in]	space = MSpace.Space
	[in]	tolerance = double


Calculates the surface area of this nurbs surface in world or local space. A value of 0.0 will be returned if the area cannot be determined successfully.'''
        pass

    def setCVs(self, array, space): 
        '''setCVs(self, array, space)
Arguments:
	[in]	array = MPointArray
	[in]	space = MSpace.Space


Set the CVs for this surface to the given points.  numCVsInU()  *  numCVsInV()  points must be provided. Converting from uIndex, vIndex is done by "index = numCVsInV() * uIndex + vIndex".'''
        pass

    def getPointAtParam(self, paramU, paramV, space, point): 
        '''getPointAtParam(self, paramU, paramV, space, point)
Arguments:
	[in]	paramU = double
	[in]	paramV = double
	[out]	point = MPoint
	[in]	space = MSpace.Space


Finds the point corresponding to the given parameter value on the surface.'''
        pass

    def create(self, controlVertices, uKnotSequences, vKnotSequences, degreeInU, degreeInV, formU, formV, createRational, parentOrOwner): 
        '''create(self, controlVertices, uKnotSequences, vKnotSequences, degreeInU, degreeInV, formU, formV, createRational, parentOrOwner) -> MObject
Returns: If parentOrOwner is NULL then the transform for this surface is returned 
If parentOrOwner is a DAG object then the new surface shape is returned 
The surface geometry is returned if parentOrOwner is of type kNurbsSurfaceData

Arguments:
	[in]	controlVertices = MPointArray
	[in]	uKnotSequences = MDoubleArray
	[in]	vKnotSequences = MDoubleArray
	[in]	degreeInU = int
	[in]	degreeInV = int
	[in]	formU = MFnNurbsSurface.Form
	[in]	formV = MFnNurbsSurface.Form
	[in]	createRational = bool
	[in]	parentOrOwner = MObject


Creates a nurbs surface from the specified data and sets this function set to operate on the new surface.'''
        pass

    def knotInU(self, index): 
        '''knotInU(self, index) -> double
Returns: The knot value

Arguments:
	[in]	index = int


Retrieve the given knot value from this surface at the specified U index. Knots are indexed from 0 to numKnots-1.'''
        pass

    def isPointInTrimmedRegion(self, u, v): 
        '''isPointInTrimmedRegion(self, u, v) -> bool
Returns: Boolean value: true if the point on surface is within a trimmed away region, false otherwise.

Arguments:
	[in]	u = double
	[in]	v = double


Returns true if the given point is in a trimmed away region of a trimmed surface. A trimmed away region is the part of the surface that is cut away as a result of a trim operation.'''
        pass

    def kClosedSegment(self):
        '''This is an enum of BoundaryType.
Description: Closed curve on a face.
Value: 4'''
        pass

    def kSegment(self):
        '''This is an enum of BoundaryType.
Description: Curve on a face.
Value: 3'''
        pass

    def kOuter(self):
        '''This is an enum of BoundaryType.
Description: Outer boundary, counter clockwise.
Value: 1'''
        pass

    def kInvalidBoundary(self):
        '''This is an enum of BoundaryType.
Description: 
Value: 0'''
        pass

    def kInner(self):
        '''This is an enum of BoundaryType.
Description: Inner boundary, clockwise.
Value: 2'''
        pass

    class BoundaryType:
        '''Non-functional class.  Values for this enum:
        kClosedSegment
        kSegment
        kOuter
        kInvalidBoundary
        kInner
'''
        def __init__(self):
            pass

    def edge(self, region, boundary, edge, paramEdge): 
        '''edge(self, region, boundary, edge, paramEdge) -> MObjectArray
Returns: A curve for the specified edge

Arguments:
	[in]	region = int
	[in]	boundary = int
	[in]	edge = int
	[in]	paramEdge = bool


Return the specified edge of a trim boundary.'''
        pass

    def removeOneKnotInU(self, atThisParam): 
        '''removeOneKnotInU(self, atThisParam)
Arguments:
	[in]	atThisParam = double


Remove one U knot at the specified parameter value from this surface.'''
        pass

    def removeOneKnotInV(self, atThisParam): 
        '''removeOneKnotInV(self, atThisParam)
Arguments:
	[in]	atThisParam = double


Remove one V knot at the specified parameter value from this surface.'''
        pass

    def intersect(self, rayStartingPoint, alongThisDirection, uArray, vArray, tolerance, space, calculateDistance, calculateExactHit, points, distances, wasExactHit): 
        '''intersect(self, rayStartingPoint, alongThisDirection, uArray, vArray, tolerance, space, calculateDistance, calculateExactHit, points, distances, wasExactHit) -> bool
Returns: Boolean value: true if an intersection point has been found, false otherwise.

Arguments:
	[in]	rayStartingPoint = MPoint
	[in]	alongThisDirection = MVector
	[in]	uArray = MDoubleArray
	[in]	vArray = MDoubleArray
	[out]	points = MPointArray
	[in]	tolerance = double
	[in]	space = MSpace.Space
	[in]	calculateDistance = bool
	[out]	distances = MDoubleArray
	[in]	calculateExactHit = bool
	[out]	wasExactHit = bool


This function determines all the points of intersection of this spline surface with a ray (a vector at a point).'''
        pass

    def isFlipNorm(self, region): 
        '''isFlipNorm(self, region) -> bool

Arguments:
	[in]	region = int


Determines whether the normal for the specified region is flipped. This method is only valid for trimmed surfaces.'''
        pass

    def removeKnotInU(self, atThisParam, removeAll): 
        '''removeKnotInU(self, atThisParam, removeAll)
Arguments:
	[in]	atThisParam = double
	[in]	removeAll = bool


Remove the U knot(s) at the specified parameter value from this surface. If there are multiple knots at this parameter then removeAll is used to specify how to do the removal.'''
        pass

    def removeKnotInV(self, atThisParam, removeAll): 
        '''removeKnotInV(self, atThisParam, removeAll)
Arguments:
	[in]	atThisParam = double
	[in]	removeAll = bool


Remove the V knot(s) at the specified parameter value from this surface. If there are multiple knots at this parameter then removeAll is used to specify how to do the removal.'''
        pass

    def type(self): 
        '''type(self) -> MFn.Type

'''
        pass

    def numNonZeroSpansInV(self): 
        '''numNonZeroSpansInV(self) -> int
Returns: The number of non-empty (non-zero, visual) spans in V


Returns the number of non-zero spans in the V direction. This value will be equivalent to the value returned by  numSpansInV()  if all of the internal (non-end) knots are of multiplicity 1. If some of the internal knots have higher multiplicity, this value will be lower than that returned by  numSpansInV() . You can use the number of non-zero spans to count the number of  visual  spans on the surface in the V direction, since the empty (zero) spans do not appear as a separate span/patch in the display.'''
        pass

    def getCV(self, indexU, indexV, space, pnt): 
        '''getCV(self, indexU, indexV, space, pnt)
Arguments:
	[in]	indexU = int
	[in]	indexV = int
	[out]	pnt = MPoint
	[in]	space = MSpace.Space


Get the location of the specified CV.'''
        pass

    def closestPoint(self, toThisPoint, paramAsStart, paramU, paramV, ignoreTrimBoundaries, tolerance, space): 
        '''closestPoint(self, toThisPoint, paramAsStart, paramU, paramV, ignoreTrimBoundaries, tolerance, space) -> MPoint
Returns: The closest point on this surface to the given point

Arguments:
	[in]	toThisPoint = MPoint
	[in]	paramAsStart = bool
	[in]	paramU = double
	[in]	paramV = double
	[in]	ignoreTrimBoundaries = bool
	[in]	tolerance = double
	[in]	space = MSpace.Space


Return the closest point on this surface to the given point.'''
        pass

    def isPointOnSurface(self, point, tolerance, space): 
        '''isPointOnSurface(self, point, tolerance, space) -> bool
Returns: Boolean value: true if the given point is on this surface, false otherwise.

Arguments:
	[in]	point = MPoint
	[in]	tolerance = double
	[in]	space = MSpace.Space


Check if the given point is on this surface.'''
        pass

    def numPatchesInU(self): 
        '''numPatchesInU(self) -> int
Returns: The number of non-zero patches along u, in this surface.


Returns the number of non-zero patches along u, in this surface.'''
        pass

    def boundaryType(self, region, boundary): 
        '''boundaryType(self, region, boundary) -> MFnNurbsSurface.BoundaryType
Returns: The boundary type: 
kInner an inner boundary, clockwise 
kOuter an outer boundary, counter clockwise 
kSegment a boundary segment (a curve on face) 
kClosedSegment a closed boundary segment (a closed curve on face) 
kInvalidBoundary an invalid boundary type

Arguments:
	[in]	region = int
	[in]	boundary = int


Returns the type of the specified boundary. The surface must be a trimmed surface.'''
        pass

    def normal(self, paramInU, paramInV, space): 
        '''normal(self, paramInU, paramInV, space) -> MVector
Returns: The normal vector

Arguments:
	[in]	paramInU = double
	[in]	paramInV = double
	[in]	space = MSpace.Space


Retrieve the normal at the given parameter value on the surface.'''
        pass

    def isUniform(self): 
        '''isUniform(self) -> bool
Returns: true Uniform knot spacing 
false Non-uniform knot spacing


Determine if the knot spacing is uniform.'''
        pass

    def isKnotU(self, param): 
        '''isKnotU(self, param) -> bool
Returns: Boolean value: true if the parameter value is a knot value, false otherwise.

Arguments:
	[in]	param = double


Check if the specified parameter value is a knot value.'''
        pass

    def numRegions(self): 
        '''numRegions(self) -> int


Returns the number of trimmed regions for this surface or 0 if the surface is not a trimmed surface.'''
        pass

    def isKnotV(self, param): 
        '''isKnotV(self, param) -> bool
Returns: Boolean value: true if the parameter value is a knot value, false otherwise.

Arguments:
	[in]	param = double


Check if the specified parameter value is a knot value.'''
        pass

    def getPatchUVid(self, patchId, cornerIndex, uvId): 
        '''getPatchUVid(self, patchId, cornerIndex, uvId)
Arguments:
	[in]	patchId = int
	[in]	cornerIndex = int
	[out]	uvId = int


Get the id of the specified texture coordinate for a corner in a patch.'''
        pass

    def numEdges(self, region, boundary): 
        '''numEdges(self, region, boundary) -> int
Returns: The number of edges for the specified boundary

Arguments:
	[in]	region = int
	[in]	boundary = int


Return the number of edges for the specified trim boundary.'''
        pass

    def isParamOnSurface(self, paramU, paramV): 
        '''isParamOnSurface(self, paramU, paramV) -> bool
Returns: Boolean value: true if the parameter value on this surface, false otherwise.

Arguments:
	[in]	paramU = double
	[in]	paramV = double


Check if the specified parameter is on this surface.'''
        pass

    def getKnotDomain(self, startU, endU, startV, endV): 
        '''getKnotDomain(self, startU, endU, startV, endV)
Arguments:
	[out]	startU = double
	[out]	endU = double
	[out]	startV = double
	[out]	endV = double


Returns the maximum and minimum U and V paramter values for this surface.'''
        pass

    def numPatches(self): 
        '''numPatches(self) -> int
Returns: The number of non-zero patches in this surface.


Returns the number of non-zero patches in this surface.'''
        pass

    def getTrimBoundaries(self, region, paramEdge, result): 
        '''getTrimBoundaries(self, region, paramEdge, result)
Arguments:
	[out]	result = MTrimBoundaryArray
	[in]	region = int
	[in]	paramEdge = bool


Returns all trim boundaries of a region on this surface.'''
        pass

    def setCV(self, indexU, indexV, pt, space): 
        '''setCV(self, indexU, indexV, pt, space)
Arguments:
	[in]	indexU = int
	[in]	indexV = int
	[in]	pt = MPoint
	[in]	space = MSpace.Space


Set the location of the specified CV.'''
        pass

    def copy(self, source, parentOrOwner): 
        '''copy(self, source, parentOrOwner) -> MObject
Returns: If parentOrOwner is NULL then the transform for this surface is returned 
If parentOrOwner is a DAG object then the new surface shape is returned 
The surface geometry is returned if parentOrOwner is of type kNurbsSurfaceData

Arguments:
	[in]	source = MObject
	[in]	parentOrOwner = MObject


This method creates a copy of a nurbs surface.'''
        pass

    def getDataObject(self): 
        '''getDataObject(self) -> MObject


Returns an  MObject  if the class has been constructed with an  MFn::kNurbsSurfaceData  entity, otherwise  MObject::kNullObj  is returned.'''
        pass

    def setUVs(self, uArray, vArray): 
        '''setUVs(self, uArray, vArray)
Arguments:
	[in]	uArray = MFloatArray
	[in]	vArray = MFloatArray


Sets all of the texture coordinates (uvs) for this surface. The uv arrays must be of equal size and must be at least of length  numUVs() . If the arrays are larger than  numUVs()  then the uv list for this surface will be grown to accommodate the new uv values.'''
        pass

    def updateSurface(self): 
        '''updateSurface(self)

This method signals that this surface has changed and needs to be recalculated.'''
        pass

    def getUV(self, uvId, u, v): 
        '''getUV(self, uvId, u, v)
Arguments:
	[in]	uvId = int
	[out]	u = float
	[out]	v = float


Get the value of the specified texture coordinate from this surface's uv list. The uvId is the element in the uv list that will be retrieved.'''
        pass

    def getPatchUV(self, patchId, cornerIndex, u, v): 
        '''getPatchUV(self, patchId, cornerIndex, u, v)
Arguments:
	[in]	patchId = int
	[in]	cornerIndex = int
	[out]	u = float
	[out]	v = float


Get the value of the specified texture coordinate for a patch corner in a patch. Since texture coordinates (uv's) are stored per-patch per-corner you must specify both the patch and the corner that the u and v values are mapped to.'''
        pass

    def cvsInV(self, startIndex, endIndex, rowIndex): 
        '''cvsInV(self, startIndex, endIndex, rowIndex) -> MObject
Returns: The component for the CVs

Arguments:
	[in]	startIndex = int
	[in]	endIndex = int
	[in]	rowIndex = int


Returns a component for the specified CVs on the given V direction.'''
        pass

    def cvsInU(self, startIndex, endIndex, rowIndex): 
        '''cvsInU(self, startIndex, endIndex, rowIndex) -> MObject
Returns: The component for the CVs on the given U direction.

Arguments:
	[in]	startIndex = int
	[in]	endIndex = int
	[in]	rowIndex = int


Returns a component for the specified CVs.'''
        pass

    def getUVs(self, uArray, vArray): 
        '''getUVs(self, uArray, vArray)
Arguments:
	[out]	uArray = MFloatArray
	[out]	vArray = MFloatArray


This method copies the texture coordinate list for this surface into the given uv arrays.'''
        pass

    def setUV(self, uvId, u, v): 
        '''setUV(self, uvId, u, v)
Arguments:
	[in]	uvId = int
	[in]	u = float
	[in]	v = float


Sets the specified texture coordinate. The uvId is the element in the uv list that will be set. If the uvId is greater than or equal to  numUVs()  then the uv list will be grown to accommodate the specified uv.'''
        pass

    def tesselate(self, parms, parentOrOwner): 
        '''tesselate(self, parms, parentOrOwner) -> MObject
Returns: If parentOrOwner is NULL then the transform for this surface is returned 
If parentOrOwner is a DAG object then the new surface shape is returned 
The surface geometry is returned if parentOrOwner is of type kMeshData

Arguments:
	[in]	parms = MTesselationParams
	[in]	parentOrOwner = MObject


Performs tesselation on this surface and create a new mesh in the DAG. The type of tesselation can be controlled by providing the tesselation parameters (see  MTesselationParams ).'''
        pass

    def getPatchUVs(self, patchId, uArray, vArray): 
        '''getPatchUVs(self, patchId, uArray, vArray)
Arguments:
	[in]	patchId = int
	[out]	uArray = MFloatArray
	[out]	vArray = MFloatArray


Get the values of the texture coordinate on a specified patch. Since texture coordinates (uvs) are stored per-patch per-corner, the u and v values mapped to all corners of the specified patch are returned.'''
        pass

    def className(self): 
        '''className(self) -> char*

'''
        pass

    def knotInV(self, index): 
        '''knotInV(self, index) -> double
Returns: The knot value

Arguments:
	[in]	index = int


Retrieve the given knot value from this surface at the specified V index. Knots are indexed from 0 to numKnots-1.'''
        pass

    def assignUV(self, patchId, cornerIndex, uvId): 
        '''assignUV(self, patchId, cornerIndex, uvId)
Arguments:
	[in]	patchId = int
	[in]	cornerIndex = int
	[in]	uvId = int


Maps a texture coordinate to a the specified corner of a patch.'''
        pass

    def getDerivativesAtParm(self, paramInU, paramInV, space, pos, dU, dV, dUU, dVV, dUV): 
        '''getDerivativesAtParm(self, paramInU, paramInV, space, pos, dU, dV, dUU, dVV, dUV)
Arguments:
	[in]	paramInU = double
	[in]	paramInV = double
	[out]	pos = MPoint
	[out]	dU = MVector
	[out]	dV = MVector
	[in]	space = MSpace.Space
	[out]	dUU = MVector
	[out]	dVV = MVector
	[out]	dUV = MVector


Evaluate the surface at the given (u,v) coordinate returning position, first derivatives and optionally second derivative information. The returned derivative vectors are not normalized. If either dUU, dVV, or dUV is set to NULL, the second derivatives will not be computed and execution time wil be faster.'''
        pass

    def numNonZeroSpansInU(self): 
        '''numNonZeroSpansInU(self) -> int
Returns: The number of non-empty (non-zero, visual) spans in U


Returns the number of non-zero spans in the U direction. This value will be equivalent to the value returned by  numSpansInU()  if all of the internal (non-end) knots are of multiplicity 1. If some of the internal knots have higher multiplicity, this value will be lower than that returned by  numSpansInU() . You can use the number of non-zero spans to count the number of  visual  spans on the surface in the U direction, since the empty (zero) spans do not appear as a separate span/patch in the display.'''
        pass

    def assignUVs(self, uvCounts, uvIds): 
        '''assignUVs(self, uvCounts, uvIds)
Arguments:
	[in]	uvCounts = MIntArray
	[in]	uvIds = MIntArray


This method maps all texture coordinates for the surface. The setUV/setUVs method is used to create the texture coordinate table for the surface. After the table is created, this method is used to map those values to each patch on a per-corner basis. The setUV/setUVs method should be called before the assignUVs method.'''
        pass

    def distanceToPoint(self, pt, space): 
        '''distanceToPoint(self, pt, space) -> double
Returns: The distance to the given point from this surface

Arguments:
	[in]	pt = MPoint
	[in]	space = MSpace.Space


Returns the distance from the given point to the closest point on the surface.'''
        pass

    def numKnotsInV(self): 
        '''numKnotsInV(self) -> int
Returns: The number of knots in V


Returns the number of knots in V including multiple end knots (spans + 2 * degree - 1).'''
        pass

    def numKnotsInU(self): 
        '''numKnotsInU(self) -> int
Returns: The number of knots in U


Returns the number of knots in U including multiple end knots (spans + 2 * degree - 1).'''
        pass

    def trimWithBoundaries(self, mBoundaries, flipNormal, e_tol, pe_tol): 
        '''trimWithBoundaries(self, mBoundaries, flipNormal, e_tol, pe_tol)
Arguments:
	[in]	mBoundaries = MTrimBoundaryArray
	[in]	flipNormal = bool
	[in]	e_tol = double
	[in]	pe_tol = double


This function trims this surface with given trim boundaries.'''
        pass

    def isBezier(self): 
        '''isBezier(self) -> bool
Returns: true Bezier surface 
false B-spline surface


Determine if the knot spacing gives us Bezier surface.'''
        pass

    def clearUVs(self): 
        '''clearUVs(self)

This method clears out all texture coordinates for the nurbsSurface, and leaves behind an empty UVset.'''
        pass

class MFnNurbsSurfaceData:
    '''Nurbs Surface function set for dependency node data. MFnNurbsSurfaceData allows the creation and manipulation of NurbsSurface data objects for use in the dependency graph.If a user written dependency node either accepts or produces Nurbs Surfaces, then this class is used to extract or create the data that comes from or goes to other dependency graph nodes. The MDataHandle::type method will return kNurbsSurface when data of this type is present.If a node is receiving a Nurbs Surface via an input attribute, the asNurbsSurface method of MDataHandle can be used to access that input Nurbs Surface.If a node is to create a Nurbs Surface and send it via an output attribute, a new MFnNurbsSurfaceData must be instantiated and then the create method called to build the actual data block as an MObject. This MObject should be passed to the MFnNurbsSurface::create method as the parentOrOwner parameter so that the Nurbs Surface will be constructed inside the data block. The MDataHandle::set routine is then used to pass the data block down the connection. '''
    def __init__(self):
        pass


    def className(self): 
        '''className(self) -> char*

'''
        pass

    def create(self): 
        '''create(self) -> MObject
Returns: The new MObject 


Create a new  MObject , attach it to this instance and initialize it with a data block capable of holding a Nurbs Surface.'''
        pass

    def type(self): 
        '''type(self) -> MFn.Type

'''
        pass

class MFnPartition:
    '''Function set for partitions of objects. MFnPartition is the function set that is used for manipulating partitions of objects.A partition is a list of dependency nodes and dag nodes. Partitions are useful for keeping track of lists of objects for many purposes such as selection or applying common rendering parameters. Partitions in Maya are also dependency nodes, so it is possible for one partition to contain others. '''
    def __init__(self):
        pass


    def addMember(self, set): 
        '''addMember(self, set)
Arguments:
	[in]	set = MObject


Add a set to this partition. To be added to a partition, a set must be mutually exclusive with all of the other sets in the partition. If there are any conflicting elements, then the add will fail.'''
        pass

    def create(self, isRenderPartition): 
        '''create(self, isRenderPartition) -> MObject
Returns: A handle for the new partition object

Arguments:
	[in]	isRenderPartition = bool


Creates a new partition dependency node and puts it in the dependency graph.'''
        pass

    def className(self): 
        '''className(self) -> char*

'''
        pass

    def removeMember(self, set): 
        '''removeMember(self, set)
Arguments:
	[in]	set = MObject


Remove a set from this partition.'''
        pass

    def isRenderPartition(self): 
        '''isRenderPartition(self) -> bool
Returns: A boolean value indicating whether the object is a member


Returns true if this partition is a render partition.'''
        pass

    def type(self): 
        '''type(self) -> MFn.Type

'''
        pass

class MFnPhongEShader:
    '''Manage phongE shaders. MFnPhongEShader facilitates creation and manipulation of dependency graph nodes representing phongE shaders. '''
    def __init__(self):
        pass


    def highlightSize(self): 
        '''highlightSize(self) -> float
Returns: The value of the "highlightSize" attribute of the shader node.


Retrieves the value of the "highlightSize" attribute of a shader node. This attribute represents the surface color of the shader.'''
        pass

    def setWhiteness(self, whiteness): 
        '''setWhiteness(self, whiteness)
Arguments:
	[in]	whiteness = MColor


Sets the value of the "whiteness" attribute of a shader node.'''
        pass

    def create(self, UIvisible): 
        '''create(self, UIvisible) -> MObject
Returns: MObject representing the new dependency node.

Arguments:
	[in]	UIvisible = bool


Creates a new layered shader dependency graph node and adds it to the dependency graph. If the UIvisible parameter is true, the new node will be connected to the shader classification node (which allows the UI to recognize the node as a shader). If UIvisible is false, the node will be created in isolation.'''
        pass

    def whiteness(self): 
        '''whiteness(self) -> MColor
Returns: The value of the "whiteness" attribute of the shader node.


Retrieves the value of the "whiteness" attribute of a shader node. This attribute represents the surface transparency of the shader.'''
        pass

    def roughness(self): 
        '''roughness(self) -> float
Returns: The value of the "roughness" attribute of the shader node.


Retrieves the value of the "roughness" attribute of a shader node.'''
        pass

    def className(self): 
        '''className(self) -> char*

'''
        pass

    def setHighlightSize(self, highlight_size): 
        '''setHighlightSize(self, highlight_size)
Arguments:
	[in]	highlight_size = float


Sets the value of the "highlightSize" attribute of a shader node.'''
        pass

    def type(self): 
        '''type(self) -> MFn.Type

'''
        pass

    def setRoughness(self, roughness): 
        '''setRoughness(self, roughness)
Arguments:
	[in]	roughness = float


Sets the value of the "roughness" attribute of a shader node.'''
        pass

class MFnPhongShader:
    '''Manage Phong Shaders. MFnPhongShader facilitates the creation and manipulation of dependency graph nodes representing Phong shaders. '''
    def __init__(self):
        pass


    def className(self): 
        '''className(self) -> char*

'''
        pass

    def cosPower(self): 
        '''cosPower(self) -> float
Returns: The value of the "cosPower" attribute of the shader node.


Retrieves the value of the "cosPower" attribute of a phong shader node. This attribute determines the size of specular highlights produced by the shader.'''
        pass

    def create(self, UIvisible): 
        '''create(self, UIvisible) -> MObject
Returns: MObject representing the new dependency node.

Arguments:
	[in]	UIvisible = bool


Creates a new phong shader dependency graph node and adds it to the dependency graph. If the UIvisible parameter is true, the new node will be connected to the shader classification node (which allows the UI to recognize the node as a shader). If UIvisible is false, the node will be created in isolation.'''
        pass

    def type(self): 
        '''type(self) -> MFn.Type

'''
        pass

    def setCosPower(self, cos_power): 
        '''setCosPower(self, cos_power)
Arguments:
	[in]	cos_power = float


Sets the value of the "cosPower" attribute of a shader node.'''
        pass

class MFnPlugin:
    '''Register and deregister plug-in services with Maya. This class is used in the initializePlugin and uninitializePlugin functions in a Maya plugin in order to register new services with Maya. The constructor for this class is passed the MObject provided by Maya as an argument to initializePlugin and uninitializePlugin. Subsequent calls are made to the various "register" methods from inside initializePlugin, and to the various "deregister" methods from inside uninitializePlugin.A plug-in's uninitializePlugin function is not called automatically when Maya exits. Meaning any code which deallocates resources or a similar task will be called when the plug-in is explicitly unloaded but not when Maya exits. In order to work-around this problem and execute the code when Maya exits use the MSceneMessage class's addCallback method with a message of "kMayaExiting". This will register a callback function that will be executed when the "kMayaExiting" message occurs. Use this message and the addCallback method to deallocate any resources when exiting.A side effect of including MFnPlugin.h is to embed an API version string into the .o file produced. If it is necessary to include MFnPlugin.h into more than one file that comprises a plugin, the preprocessor macro  should be defined in all but one of those files prior to the inclusion of MFnPlugin.h. If this is not done, the linker will produce warnings about multiple definitions of the variable  as the .so file is being produced. These warning are harmless and can be ignored. Normally, this will not arise as only the file that contains the  and  routines should need to include MFnPlugin.h.It is possible to instantiate several MFnPlugin objects with in a single plug-in binary. The vendor and version information that is set for this plug-in is taken from the first instantiation as this information works per binary rather than per command/node etc.Modules are related to the topic of plug-ins and are described next.Modules provide a way of informing Maya where a third party plug-in has been installed. This is the recommended way of allowing Maya to know that a plug-in is available and is important for 3rd party developers who deliver plug-ins outside of the Maya installation procedure.The list of directories that Maya searches for modules can be accessed through the MAYA_MODULE_PATH environment variable. Please consult the online documentation for more details on this environment variable. To examine this variable value, run the following from the MEL script editor:The MAYA_MODULE_PATH contains a list of directories and within each module directory there are subdirectories that look like:Within that directory are zero or more text files. Each file has a single line that looks like this:The fields are defined as:If we had a plug-in named doubleHelix, the single line for a Windows installation might be:On Linux, we might have:When Maya starts up it will search the paths defined by MAYA_MODULE_PATH. For any paths found it will do the following:When the Plug-in Manager is opened it will display the plug-ins described by the module files since the appropriate paths have been modified. Following the subdirectory naming structure using "plug-ins", "scripts" and "icons" will allow Maya to find your files properly. The "resources" directory is used when maya is running in a localized language. Subdirectories of the form "resources/<LANG>" can be used to provide localized plug-in resources for the corresponding language. The subdir name  will correspond to the value returned by `about -uiLanguage`. On Macintosh platforms, language subdirs of the form "<b>LANG</b>.lproj" are also supported.NOTE: a specific module path may not exist on disk. This will not cause an error. Maya will skip over this path and continue to process the others. '''
    def __init__(self):
        pass


    def deregisterDevice(self, deviceName): 
        '''deregisterDevice(self, deviceName)
Arguments:
	[in]	deviceName = MString


Deregister the given user defined input device from Maya.'''
        pass

    def setRegisteringCallableScript(self): 
        '''setRegisteringCallableScript(self)
'''
        pass

    def registerTransform(self, typeName, typeId, creatorFunction, initFunction, xformCreatorFunction, xformId, classification): 
        '''registerTransform(self, typeName, typeId, creatorFunction, initFunction, xformCreatorFunction, xformId, classification)
Arguments:
	[in]	typeName = MString
	[in]	typeId = MTypeId
	[in]	creatorFunction = MFnPlugin.MCreatorFunction
	[in]	initFunction = MFnPlugin.MInitializeFunction
	[in]	xformCreatorFunction = MFnPlugin.MCreateXformMatrixFunction
	[in]	xformId = MTypeId
	[in]	classification = MString


Registers the given user defined transform node with Maya. Once registered, the transform can be used from MEL in a manner identical to built-in Maya nodes.'''
        pass

    def deregisterControlCommand(self, commandName): 
        '''deregisterControlCommand(self, commandName)
Arguments:
	[in]	commandName = MString


Deregister the user defined control command from Maya. Once deregistered the command can no longer be invoked from MEL.'''
        pass

    def registerFileTranslator(self, translatorName, pixmapName, creatorFunction, optionsScriptName, defaultOptionsString, requiresFullMel): 
        '''registerFileTranslator(self, translatorName, pixmapName, creatorFunction, optionsScriptName, defaultOptionsString, requiresFullMel)
Arguments:
	[in]	translatorName = MString
	[in]	pixmapName = char
	[in]	creatorFunction = MFnPlugin.MCreatorFunction
	[in]	optionsScriptName = char
	[in]	defaultOptionsString = char
	[in]	requiresFullMel = bool


Register a new file translator with Maya.'''
        pass

    def addMenuItem(self, menuItemName, parentName, commandName, commandParams, needOptionBox, optBoxFunction): 
        '''addMenuItem(self, menuItemName, parentName, commandName, commandParams, needOptionBox, optBoxFunction) -> MStringArray
Returns: MStringArray returns the names of the new menuItems created. In case the method fails, and MStringArray has items in it, removeMenuItem() should be called on it to remove the unused UI references. 

Arguments:
	[in]	menuItemName = MString
	[in]	parentName = MString
	[in]	commandName = MString
	[in]	commandParams = MString
	[in]	needOptionBox = bool
	[in]	optBoxFunction = MString


The function adds the menuItem to the specified parent, and associates a command with it. Additionally, an option box can be created and a MEL function/command can be added to it. The function returns the names of the new menuItem and the optionBox created.'''
        pass

    def registerDevice(self, deviceName, creatorFunction): 
        '''registerDevice(self, deviceName, creatorFunction)
Arguments:
	[in]	deviceName = MString
	[in]	creatorFunction = MFnPlugin.MCreatorFunction


Register a new input device with Maya. Once registered, the new input device can be connected to Maya actions using the  assignInputDevice  command in MEL in a manner identical to built-in Maya devices.  In Maya 1.0, only Midi input devices are supported and the creatorFunction must return a pointer to a  MPxMidiInputDevice  instance. This interface will be generalized in a future release.'''
        pass

    def registerConstraintCommand(self, commandName, creatorFunction): 
        '''registerConstraintCommand(self, commandName, creatorFunction)
Arguments:
	[in]	commandName = MString
	[in]	creatorFunction = MFnPlugin.MCreatorFunction


Register a new constraint command with Maya. Once registered, the command can be invoked from MEL in a manner identical to built-in Maya commands.'''
        pass

    def registerModelEditorCommand(self, commandName, creatorFunction, viewCreatorFunction): 
        '''registerModelEditorCommand(self, commandName, creatorFunction, viewCreatorFunction)
Arguments:
	[in]	commandName = MString
	[in]	creatorFunction = MFnPlugin.MCreatorFunction
	[in]	viewCreatorFunction = MFnPlugin.MCreatorFunction


Register a new model editor command with Maya. Once registered, the command can be invoked from MEL in a manner identical to built-in Maya commands.'''
        pass

    def deregisterContextCommand(self, commandName, toolCmdName): 
        '''deregisterContextCommand(self, commandName, toolCmdName)
Arguments:
	[in]	commandName = MString
	[in]	toolCmdName = MString


Deregister the given user defined context command and tool command from Maya. Once deregistered the user defined tool can no longer be used and the tool command can no longer be invoked from MEL.'''
        pass

    def setVersion(self, newVersion): 
        '''setVersion(self, newVersion)
Arguments:
	[in]	newVersion = MString


Set the version name for this plug-in.'''
        pass

    def deregisterNode(self, typeId): 
        '''deregisterNode(self, typeId)
Arguments:
	[in]	typeId = MTypeId


Deregister the given user defined dependency node type Maya. Once deregistered new instances of the user defined dependency node can no longer be created. Additionally, any existing instances of the node type will be changed to the special type  Unknown  and will no longer evaluate in the dependency graph although they will be saved correctly if the scene is written.'''
        pass

    def registerMaterialInfo(self, materialInfoName, fnPtr): 
        '''registerMaterialInfo(self, materialInfoName, fnPtr)
Arguments:
	[in]	materialInfoName = MString
	[in]	fnPtr = MMaterialInfoFactoryFnPtr


Registers a new material information type with Maya.'''
        pass

    def deregisterCommand(self, commandName): 
        '''deregisterCommand(self, commandName)
Arguments:
	[in]	commandName = MString


Deregister the user defined command from Maya. Once deregistered the command can no longer be invoked from MEL.'''
        pass

    def registerIkSolver(self, ikSolverName, creatorFunction): 
        '''registerIkSolver(self, ikSolverName, creatorFunction)
Arguments:
	[in]	ikSolverName = MString
	[in]	creatorFunction = MFnPlugin.MCreatorFunction


Register a new ik-solver with Maya. NOTE: this method is obsolete. Instead, register the IK solver as a node as described in the example plug-in simpleSolverNode.cpp.'''
        pass

    def deregisterModelEditorCommand(self, commandName): 
        '''deregisterModelEditorCommand(self, commandName)
Arguments:
	[in]	commandName = MString


Deregister the user defined editor command from Maya. Once deregistered the command can no longer be invoked from MEL.'''
        pass

    def matrixTypeIdFromXformId(self, xformTypeId): 
        '''matrixTypeIdFromXformId(self, xformTypeId) -> MTypeId
Returns: MTypeId TypeId of the corresponding transformation matrix, if found. 

Arguments:
	[in]	xformTypeId = MTypeId


The function returns the  MTypeId  of the matrix when the  MTypeId  of the corresponding xform is given.'''
        pass

    def deregisterImageFile(self, imageFormatName): 
        '''deregisterImageFile(self, imageFormatName)
Arguments:
	[in]	imageFormatName = MString


Deregister the specified image file translator with Maya.'''
        pass

    def registerBakeEngine(self, bakeEngineGenName, fnPtr): 
        '''registerBakeEngine(self, bakeEngineGenName, fnPtr)
Arguments:
	[in]	bakeEngineGenName = MString
	[in]	fnPtr = MBakeEngineCreatorFnPtr


Registers a new bake engine type with Maya.'''
        pass

    def version(self): 
        '''version(self) -> MString
Returns: An MString containing the version string


Return the version string supplied in the  MFnPlugin  constructor.'''
        pass

    def removeMenuItem(self, menuItemNames): 
        '''removeMenuItem(self, menuItemNames)
Arguments:
	[in]	menuItemNames = MStringArray


The function removes the menuItem and the corresponding option box, if exists, from the UI.'''
        pass

    def type(self): 
        '''type(self) -> MFn.Type


Return the type of this function set.'''
        pass

    def registeringCallableScript(self): 
        '''registeringCallableScript(self) -> bool

'''
        pass

    def deregisterCacheFormat(self, cacheFormatName): 
        '''deregisterCacheFormat(self, cacheFormatName)
Arguments:
	[in]	cacheFormatName = MString


Deregister the specified cache format with Maya.'''
        pass

    def registerUIStrings(self, registerMStringResources, pluginStringsProc): 
        '''registerUIStrings(self, registerMStringResources, pluginStringsProc)
Arguments:
	[in]	registerMStringResources = MFnPlugin.MInitializeFunction
	[in]	pluginStringsProc = MString


Set the callback and procedure names of routines that register plugin string resources and optionally load localized values for them.'''
        pass

    def vendor(self): 
        '''vendor(self) -> MString
Returns: An MString containing the vendor name


Return the vendor string supplied in the  MFnPlugin  constructor.'''
        pass

    def setName(self, newName, makeUnique): 
        '''setName(self, newName, makeUnique)
Arguments:
	[in]	newName = MString
	[in]	makeUnique = bool


Set the name by which Maya knows this plug-in.'''
        pass

    def registerCacheFormat(self, cacheFormatName, creatorFunction): 
        '''registerCacheFormat(self, cacheFormatName, creatorFunction)
Arguments:
	[in]	cacheFormatName = MString
	[in]	creatorFunction = MFnPlugin.MCreatorFunction


Register a new cache format with Maya.'''
        pass

    def deregisterDragAndDropBehavior(self, behaviorName): 
        '''deregisterDragAndDropBehavior(self, behaviorName)
Arguments:
	[in]	behaviorName = MString


Deregister the given drag and drop behavior from Maya.'''
        pass

    def registerCommand(self, commandName, creatorFunction, createSyntaxFunction): 
        '''registerCommand(self, commandName, creatorFunction, createSyntaxFunction)
Arguments:
	[in]	commandName = MString
	[in]	creatorFunction = MFnPlugin.MCreatorFunction
	[in]	createSyntaxFunction = MFnPlugin.MCreateSyntaxFunction


Register a new command with Maya. Once registered, the command can be invoked from MEL in a manner identical to built-in Maya commands.'''
        pass

    def registerShape(self, typeName, typeId, creatorFunction, initFunction, uiCreatorFunction, classification): 
        '''registerShape(self, typeName, typeId, creatorFunction, initFunction, uiCreatorFunction, classification)
Arguments:
	[in]	typeName = MString
	[in]	typeId = MTypeId
	[in]	creatorFunction = MFnPlugin.MCreatorFunction
	[in]	initFunction = MFnPlugin.MInitializeFunction
	[in]	uiCreatorFunction = MFnPlugin.MCreatorFunction
	[in]	classification = MString


Registers the given user defined shape node with Maya. Once registered, the shape can be used from MEL in a manner identical to built-in Maya nodes.'''
        pass

    def deregisterIkSolver(self, ikSolverName): 
        '''deregisterIkSolver(self, ikSolverName)
Arguments:
	[in]	ikSolverName = MString


Deregister the specified ik-solver with Maya. NOTE: this method is obsolete. Instead, register the IK solver as a node as described in the example plug-in simpleSolverNode.cpp.'''
        pass

    def registerNode(self, typeName, typeId, creatorFunction, initFunction, type, classification): 
        '''registerNode(self, typeName, typeId, creatorFunction, initFunction, type, classification)
Arguments:
	[in]	typeName = MString
	[in]	typeId = MTypeId
	[in]	creatorFunction = MFnPlugin.MCreatorFunction
	[in]	initFunction = MFnPlugin.MInitializeFunction
	[in]	type = MPxNode.Type
	[in]	classification = MString


Register a new dependency node with Maya. Once registered, the node can be used from MEL in a manner identical to built-in Maya nodes.'''
        pass

    def deregisterData(self, typeId): 
        '''deregisterData(self, typeId)
Arguments:
	[in]	typeId = MTypeId


Deregister the given user defined data type from Maya.'''
        pass

    def deregisterConstraintCommand(self, commandName): 
        '''deregisterConstraintCommand(self, commandName)
Arguments:
	[in]	commandName = MString


Deregister the user defined constraint command from Maya. Once deregistered the command can no longer be invoked from MEL.'''
        pass

    def registerDragAndDropBehavior(self, behaviorName, creatorFunction): 
        '''registerDragAndDropBehavior(self, behaviorName, creatorFunction)
Arguments:
	[in]	behaviorName = MString
	[in]	creatorFunction = MFnPlugin.MCreatorFunction


Register a new drag and drop behavior with Maya. Once registered, the new behavior can be used to finish connections between node drag and drops from the hyperGraph/hyperShade to other nodes or Maya UI.'''
        pass

    def registerContextCommand(self, commandName, creatorFunction, toolCmdName, toolCmdCreator, toolCmdSyntax): 
        '''registerContextCommand(self, commandName, creatorFunction, toolCmdName, toolCmdCreator, toolCmdSyntax)
Arguments:
	[in]	commandName = MString
	[in]	creatorFunction = MFnPlugin.MCreatorFunction
	[in]	toolCmdName = MString
	[in]	toolCmdCreator = MFnPlugin.MCreatorFunction
	[in]	toolCmdSyntax = MFnPlugin.MCreateSyntaxFunction


Register a new context command and a new tool command with Maya. This version of registerContextCommand must be used if a tool command (a class derived from  MPxToolCommand ) is used within the context. The method newToolCommand of  MPxContext  will return a new instance of the tool command that can be used in the context.'''
        pass

    def registerRenderPassImpl(self, passImplId, passDef, creatorFunction, overload): 
        '''registerRenderPassImpl(self, passImplId, passDef, creatorFunction, overload)
Arguments:
	[in]	passImplId = MString
	[in]	passDef = MRenderPassDef
	[in]	creatorFunction = MFnPlugin.MCreatorFunction
	[in]	overload = bool


Register a new render pass implementation with Maya and associate with the given render pass definition. If an implementation with id passImplId has already been registered and creatorFunction is the same as the already registered creator function then the existing implementation will also be used for the current pass (SAME instances). It is an error if the passImplId is already defined and a different creatorFunction is used. If you wish to associate DIFFERENT instances of the same pass implementation with different passes, then use unique passImplIds when registering each.'''
        pass

    def loadPath(self): 
        '''loadPath(self) -> MString
Returns: An MString containing path name to the location of the plugin. 


Determine the path where the plugin was loaded.'''
        pass

    def unregisterMaterialInfo(self, materialInfoName): 
        '''unregisterMaterialInfo(self, materialInfoName)
Arguments:
	[in]	materialInfoName = MString


Deregister the specified material info type with Maya.'''
        pass

    def name(self): 
        '''name(self) -> MString
Returns: An MString containing the plug-in name 


Return the name by which Maya knows this plug-in.'''
        pass

    def registerControlCommand(self, commandName, creatorFunction): 
        '''registerControlCommand(self, commandName, creatorFunction)
Arguments:
	[in]	commandName = MString
	[in]	creatorFunction = MFnPlugin.MCreatorFunction


Register a new control command with Maya. Once registered, the command can be invoked from MEL in a manner identical to built-in Maya commands.'''
        pass

    def registerImageFile(self, imageFormatName, creatorFunction, imageFileExtensions): 
        '''registerImageFile(self, imageFormatName, creatorFunction, imageFileExtensions)
Arguments:
	[in]	imageFormatName = MString
	[in]	creatorFunction = MFnPlugin.MCreatorFunction
	[in]	imageFileExtensions = MStringArray


Register a new image file translator with Maya.'''
        pass

    def deregisterFileTranslator(self, translatorName): 
        '''deregisterFileTranslator(self, translatorName)
Arguments:
	[in]	translatorName = MString


Deregister the specified file translator with Maya.'''
        pass

    def unregisterBakeEngine(self, bakeEngineGenName): 
        '''unregisterBakeEngine(self, bakeEngineGenName)
Arguments:
	[in]	bakeEngineGenName = MString


Deregister the bake engine type with Maya.'''
        pass

    def isNodeRegistered(self, typeName): 
        '''isNodeRegistered(self, typeName) -> bool
Returns: true if registered, false otherwise. 

Arguments:
	[in]	typeName = MString


Queries if the given typeName has been registered by maya or plugins.'''
        pass

    def apiVersion(self): 
        '''apiVersion(self) -> MString
Returns: An MString containing the required API version string 


Return the required API version string supplied in the  MFnPlugin  constructor.'''
        pass

    def findPlugin(self, pluginName): 
        '''findPlugin(self, pluginName) -> MObject
Returns: An MObject corresponding to the plugin if the plugin is loaded. 
MObject::kNullObj if the plugin isn't loaded. 

Arguments:
	[in]	pluginName = MString


Returns an  MObject  corresponding to the named plugin. If the plugin isn't loaded, the  MObject  will be kNullObj. This  MObject  may be used in the same way as the  MObject  passed to the plugin's initializePlugin() function. Do not hold onto this  MObject , if you need it again later, call  findPlugin()  again.'''
        pass

    def deregisterRenderPassImpl(self, passImplId): 
        '''deregisterRenderPassImpl(self, passImplId)
Arguments:
	[in]	passImplId = MString


Deregister the specified render pass implementation with Maya. This will remove the implementation from all passes it is associated with.'''
        pass

    def registerData(self, typeName, typeId, creatorFunction, type): 
        '''registerData(self, typeName, typeId, creatorFunction, type)
Arguments:
	[in]	typeName = MString
	[in]	typeId = MTypeId
	[in]	creatorFunction = MFnPlugin.MCreatorFunction
	[in]	type = MPxData.Type


Register a new data type with Maya. Once registered, the data type can be passed between dependency nodes in a manner identical to built-in Maya data types.'''
        pass

class MFnPluginData:
    '''User defined data function set for dependency node data. All user defined data that is to be passed between nodes in the dependency graph must be derived from MPxData. The use of this class is closely linked to the use of MPxData, MFnPluginData, MDataHandle, and MTypeId.In order to use user defined data, one must first create an instance of the MTypeId class that is initialized with a unique id tag. Then create a new class derived from MPxData to hold the user-defined data, As well as a helper class derived from MPxData that can create instances of the new derived type.For data of this type that needs to be passed into a plug, one would get an MDataHandle for the attribute that uses the type. This would result in a call to the MPxData helper class that would create an instance of the type inside the MDataHandle. The MDataHandle::data method can then be used to get an get an MObject for the user defined data and this should be used to initialize an instance of MFnPluginData. Then the MFnPluginData::data method can be used to get an MPxData pointer, which can be safely cast to a pointer of the user defined type. The data can be updated through this pointer, after which the MDataHandle::setClean method is used to complete the operation.To receive data of this type from a plug, an MDataHandle for the attribute that uses the new data type is created. The MDataHandle::type method should be used to ascertain that it contains kPlugin data. Then the MDataHandle::data method is used to get an MObject for the user defined data and this should be used to initialize an instance of MFnPluginData. The MFnPluginData::typeId method can be used to ascertain that the data is in fact of the user defined type. Then the MFnPluginData::data method can be used to get an MPxData pointer, which can be safely cast to a pointer to the user defined type. '''
    def __init__(self):
        pass


    def typeId(self): 
        '''typeId(self) -> MTypeId
Returns: The unique MTypeId of the data held in this instance 


Return the unique  MTypeId  of the user defined data that is held by this instance.'''
        pass

    def data(self): 
        '''data(self) -> MPxData
Returns: A pointer to the MPxData base class for the user defined data 


Return a pointer to the user defined data held in this instance.'''
        pass

    def create(self, id): 
        '''create(self, id) -> MObject
Returns: An MObject that represents an instance of the user defined data type. This will be set to MObject::kNullObj if the create failes. 

Arguments:
	[in]	id = MTypeId


Create an instance of MPluginData and initialize it to represent user defined data of the given type.'''
        pass

    def className(self): 
        '''className(self) -> char*

'''
        pass

    def MPxData(self): 
        '''MPxData(self) -> const
Returns: A constant pointer to the MPxData base class for the user defined data 


Return a constant pointer to the user defined data held in this instance.'''
        pass

    def type(self): 
        '''type(self) -> MFn.Type

'''
        pass

class MFnPointArrayData:
    '''Point array function set for dependency node data. MFnPointArrayData allows the creation and manipulation of MPointArray data objects for use in the dependency graph.If a user written dependency node either accepts or produces MPointArrays, then this class is used to extract or create the data that comes from or goes to other dependency graph nodes. The MDataHandle::type method will return kPointArray when data of this type is present. To access it, the MDataHandle::data method is used to get an MObject for the data and this should then be used to initialize an instance of MFnPointArrayData. '''
    def __init__(self):
        pass


    def set(self, array): 
        '''set(self, array)
Arguments:
	[in]	array = MPointArray


Set the instance to contain the points defined in the given  MPointArray .'''
        pass

    def create(self, arr): 
        '''create(self, arr) -> MObject
Returns: The newly created MObject 

Arguments:
	[in]	arr = MPointArray


Create a new  MObject , attach it to this instance, and initialize it to contain the data from the given  MPointArray .'''
        pass

    def copyTo(self, dest): 
        '''copyTo(self, dest)
Arguments:
	[out]	dest = MPointArray


Copy all the points in the instance into the given  MPointArray . No checking is done by this class on sizes, so it is up to the user to ensure that the given  MPointArray  is large enough to hold the number of MPoints in the instance.'''
        pass

    def className(self): 
        '''className(self) -> char*

'''
        pass

    def length(self): 
        '''length(self) -> int
Returns: The number of points in the instance 


Return the number of points in the instance.'''
        pass

    def array(self): 
        '''array(self) -> MPointArray
Returns: A copy of the MPointArray held in this instance 


Get an  MPointArray  containing the points stored in this instance. The  MPointArray  returned by this method is editable, so any changes to the return instance also affects the  MObject  operated upon by this function set.'''
        pass

    def type(self): 
        '''type(self) -> MFn.Type

'''
        pass

class MFnPointLight:
    '''Manage Point Light dependency Nodes. MFnPointLight facilitates creation and manipulation of dependency graph nodes representing point lights. '''
    def __init__(self):
        pass


    def className(self): 
        '''className(self) -> char*

'''
        pass

    def create(self, parent, UIvisible, wantTransform): 
        '''create(self, parent, UIvisible, wantTransform) -> MObject
Returns: MObject representing the new dependency node.

Arguments:
	[in]	parent = MObject
	[in]	UIvisible = bool
	[in]	wantTransform = bool


Creates a new point light dependency graph node and adds it to the dependency graph. If the UIvisible parameter is true, the new node will be connected to the light classification node (which allows the UI to recognize the node as a light) and added to the default light list. If UIvisible is false, the node will be created in isolation.'''
        pass

    def type(self): 
        '''type(self) -> MFn.Type

'''
        pass

class MFnReflectShader:
    '''Manage Reflective Surface Shaders. MFnReflectShader allows manipulation of dependency graph nodes representing reflective surface shaders. This includes Phong and Blinn shaders. '''
    def __init__(self):
        pass


    def setReflectedColor(self, reflected_color): 
        '''setReflectedColor(self, reflected_color)
Arguments:
	[in]	reflected_color = MColor


Sets the value of the "reflectedColor" attribute of a shader node.'''
        pass

    def reflectedRayDepthLimit(self): 
        '''reflectedRayDepthLimit(self) -> short
Returns: The value of the "reflectedRayDepthLimit" attribute of the node.


Retrieves the value of the "reflectedRayDepthLimit" attribute of a reflective shader node. This attribute represents the maximum reflected ray depth used in the shading calculation.'''
        pass

    def setSpecularColor(self, specular_color): 
        '''setSpecularColor(self, specular_color)
Arguments:
	[in]	specular_color = MColor


Sets the value of the "specularColor" attribute of a shader node.'''
        pass

    def setReflectedRayDepthLimit(self, reflected_ray_depth_limit): 
        '''setReflectedRayDepthLimit(self, reflected_ray_depth_limit)
Arguments:
	[in]	reflected_ray_depth_limit = short


Sets the value of the "reflectedRayDepthLimit" attribute of a lambert shader node.'''
        pass

    def reflectivity(self): 
        '''reflectivity(self) -> float
Returns: The value of the "reflectivity" attribute of the shader node.


Retrieves the value of the "reflectivity" attribute of a reflective shader node. This attribute represents the reflectivity of the shader.'''
        pass

    def setReflectivity(self, reflect): 
        '''setReflectivity(self, reflect)
Arguments:
	[in]	reflect = float


Sets the value of the "reflectivity" attribute of a shader node.'''
        pass

    def className(self): 
        '''className(self) -> char*

'''
        pass

    def specularColor(self): 
        '''specularColor(self) -> MColor
Returns: The value of the "specularColor" attribute of the shader node.


Retrieves the value of the "specularColor" attribute of a reflective shader node. This attribute represents the color of specular highlights produced by the shader.'''
        pass

    def reflectedColor(self): 
        '''reflectedColor(self) -> MColor
Returns: The value of the "reflectedColor" attribute of the shader node.


Retrieves the value of the "reflectedColor" attribute of a reflective shader node. This attribute represents the color of reflection produced by the shader.'''
        pass

    def type(self): 
        '''type(self) -> MFn.Type

'''
        pass

class MFnSet:
    '''Function Set for Sets of Objects. MFnSet is the function set that is used for manipulating sets of objects. Sets in Maya are dependency nodes, so it is possible for one set to contain others.A set is a list of dependency nodes and dag nodes. Sets are useful for keeping track of lists of objects for many purposes such as selection or applying common rendering parameters. Sets in Maya are also dependency nodes, so it is possible for one set to contain others. '''
    def __init__(self):
        pass


    def kEdgesOnly(self):
        '''This is an enum of Restriction.
Description: 
Value: 2'''
        pass

    def kVerticesOnly(self):
        '''This is an enum of Restriction.
Description: 
Value: 1'''
        pass

    def kFacetsOnly(self):
        '''This is an enum of Restriction.
Description: 
Value: 3'''
        pass

    def kNone(self):
        '''This is an enum of Restriction.
Description: 
Value: 0'''
        pass

    def kRenderableOnly(self):
        '''This is an enum of Restriction.
Description: 
Value: 5'''
        pass

    def kEditPointsOnly(self):
        '''This is an enum of Restriction.
Description: 
Value: 4'''
        pass

    class Restriction:
        '''Non-functional class.  Values for this enum:
        kEdgesOnly
        kVerticesOnly
        kFacetsOnly
        kNone
        kRenderableOnly
        kEditPointsOnly
'''
        def __init__(self):
            pass

    def addMember(self, plug): 
        '''addMember(self, plug)
Arguments:
	[in]	plug = MPlug


Add a new plug to the set.'''
        pass

    def removeMembers(self, list): 
        '''removeMembers(self, list)
Arguments:
	[in]	list = MSelectionList


Remove items of the selection list from the set.'''
        pass

    def restriction(self): 
        '''restriction(self) -> MFnSet.Restriction
Returns: The type of restriction


Returns the type of membership restriction that this set has.'''
        pass

    def intersectsWith(self, otherSet): 
        '''intersectsWith(self, otherSet) -> bool
Returns: Boolean value indicating whether there was an intersection

Arguments:
	[in]	otherSet = MObject


Returns true if this set intersects with the given set. An intersection occurs if there are any common members between the two sets.'''
        pass

    def create(self, members, restriction): 
        '''create(self, members, restriction) -> MObject
Returns: A handle for the new set object

Arguments:
	[in]	members = MSelectionList
	[in]	restriction = MFnSet.Restriction


Creates a new set dependency node and puts it in the dependency graph.'''
        pass

    def getIntersection(self, setList, result): 
        '''getIntersection(self, setList, result)
Arguments:
	[in]	setList = MObjectArray
	[out]	result = MSelectionList


This method calculates the intersection of a list of sets. The result will be the intersection of this set and the sets passed into the method.'''
        pass

    def annotation(self): 
        '''annotation(self) -> MString
Returns: The annotation string


Returns the annotation string for this set. This allows a description of the set to be stored with it.'''
        pass

    def className(self): 
        '''className(self) -> char*

'''
        pass

    def getUnion(self, setList, result): 
        '''getUnion(self, setList, result)
Arguments:
	[in]	setList = MObjectArray
	[out]	result = MSelectionList


This method calculates the union of a list of sets. The result will be the union of this set and the sets passed into the method.'''
        pass

    def removeMember(self, plug): 
        '''removeMember(self, plug)
Arguments:
	[in]	plug = MPlug


Remove an plug from the set.'''
        pass

    def isMember(self, plug): 
        '''isMember(self, plug) -> bool
Returns: A boolean value indicating whether the plug is a member

Arguments:
	[in]	plug = MPlug


Returns true if the given plug is a member of this set'''
        pass

    def getMembers(self, flatten, members): 
        '''getMembers(self, flatten, members)
Arguments:
	[out]	members = MSelectionList
	[in]	flatten = bool


Get the members of this set as a selection list. This information is provided as a selection list so that all of the path information is retained for DAG nodes.'''
        pass

    def addMembers(self, list): 
        '''addMembers(self, list)
Arguments:
	[in]	list = MSelectionList


Add a list of new objects to the set.'''
        pass

    def setAnnotation(self, annotation): 
        '''setAnnotation(self, annotation)
Arguments:
	[in]	annotation = MString


Sets the annotation string for this set. This allows a description of the set to be stored with it.'''
        pass

    def type(self): 
        '''type(self) -> MFn.Type

'''
        pass

    def clear(self): 
        '''clear(self)

Removes all elements from this set'''
        pass

    def hasRestrictions(self): 
        '''hasRestrictions(self) -> bool
Returns: A boolean value indicating whether this set has restriction


Returns true if this function set has restrictions on the type of objects that it may contain.'''
        pass

class MFnSingleIndexedComponent:
    '''Single indexed component function set. This function set allows you to create, edit, and query single indexed components. Single indexed components store 1 dimensional index values. '''
    def __init__(self):
        pass


    def getCompleteData(self, numElements): 
        '''getCompleteData(self, numElements)
Arguments:
	[out]	numElements = int


Returns the number of elements for the complete component. A complete component means that all elements are selected.'''
        pass

    def getElements(self, elements): 
        '''getElements(self, elements)
Arguments:
	[out]	elements = MIntArray


Get all of the element indices from the component.'''
        pass

    def create(self, compType): 
        '''create(self, compType) -> MObject
Returns: The new component

Arguments:
	[in]	compType = MFn.Type


Create a single indexed component of the given type. Allowable types are'''
        pass

    def element(self, index): 
        '''element(self, index) -> int
Returns: The index of the specified component

Arguments:
	[in]	index = int


Returns the specified element from the component.'''
        pass

    def className(self): 
        '''className(self) -> char*

'''
        pass

    def setCompleteData(self, numElements): 
        '''setCompleteData(self, numElements)
Arguments:
	[in]	numElements = int


Marks the component as complete (meaning all items are selected) and uses the argument to identify the total number of elements selected. If the component should contain N element indices, then the range would be [0,N-1].'''
        pass

    def type(self): 
        '''type(self) -> MFn.Type

'''
        pass

    def addElement(self, element): 
        '''addElement(self, element)
Arguments:
	[in]	element = int


Add the specified element to the component.'''
        pass

    def addElements(self, elements): 
        '''addElements(self, elements)
Arguments:
	[in]	elements = MIntArray


Add the specified elements to the component.'''
        pass

class MFnSphereData:
    '''Sphere function set for dependency node data . MFnSphereData allows the creation and manipulation of sphere (represented as MObjects) data objects for use in the dependency graph.If a user written dependency node either accepts or produces MObjects containing spheres, then this class is used to extract or create the data that comes from or goes to other dependency graph nodes. The MDataHandle::type method will return kSphere when data of this type is present. To access it, the MDataHandle::data method is used to get an MObject for the data and this should then be used to initialize an instance of MFnNurbsSurface. '''
    def __init__(self):
        pass


    def className(self): 
        '''className(self) -> char*

'''
        pass

    def radius(self): 
        '''radius(self) -> double
Returns: The radius 


Return the radius of the sphere attached to this instance.'''
        pass

    def create(self, rad): 
        '''create(self, rad) -> MObject
Returns: The new MObject 

Arguments:
	[in]	rad = double


Create a new sphere of the given radius, and attach it to this instance as an  MObject .'''
        pass

    def setRadius(self, rad): 
        '''setRadius(self, rad)
Arguments:
	[in]	rad = double


Change the radius of the sphere attached to this instance instance as an  MObject .'''
        pass

    def type(self): 
        '''type(self) -> MFn.Type

'''
        pass

class MFnSpotLight:
    '''Manage Spot Light dependency Nodes. MFnSpotLight facilitates creation and manipulation of dependency graph nodes representing spotlights. '''
    def __init__(self):
        pass


    def setBarnDoorAngle(self, which_door, barn_door_angle): 
        '''setBarnDoorAngle(self, which_door, barn_door_angle)
Arguments:
	[in]	which_door = MFnSpotLight.MBarnDoor
	[in]	barn_door_angle = double


Sets the value of the appropriate barn door angle attribute of a light node.'''
        pass

    def kThird(self):
        '''This is an enum of MDecayRegion.
Description: 
Value: 2'''
        pass

    def kFirst(self):
        '''This is an enum of MDecayRegion.
Description: 
Value: 0'''
        pass

    def kSecond(self):
        '''This is an enum of MDecayRegion.
Description: 
Value: 1'''
        pass

    class MDecayRegion:
        '''Non-functional class.  Values for this enum:
        kThird
        kFirst
        kSecond
'''
        def __init__(self):
            pass

    def kLeft(self):
        '''This is an enum of MBarnDoor.
Description: 
Value: 0'''
        pass

    def kTop(self):
        '''This is an enum of MBarnDoor.
Description: 
Value: 2'''
        pass

    def kRight(self):
        '''This is an enum of MBarnDoor.
Description: 
Value: 1'''
        pass

    def kBottom(self):
        '''This is an enum of MBarnDoor.
Description: 
Value: 3'''
        pass

    class MBarnDoor:
        '''Non-functional class.  Values for this enum:
        kLeft
        kTop
        kRight
        kBottom
'''
        def __init__(self):
            pass

    def dropOff(self): 
        '''dropOff(self) -> double
Returns: The value of the "dropOff" attribute of the light node.


Retrieves the value of the "dropOff" attribute of a light node. This attribute represents the degree to which intensity of the light decreases with increasing angular distance from the light direction vector. Higher values represent more rapid intensity dropoff.'''
        pass

    def penumbraAngle(self): 
        '''penumbraAngle(self) -> double
Returns: The value of the "penumbraAngle" attribute of the light node.


Retrieves the value of the "penumbraAngle" attribute of a light node. This attribute represents the extra angle beyond the cone angle used in soft shadow computations.'''
        pass

    def create(self, parent, UIvisible, wantTransform): 
        '''create(self, parent, UIvisible, wantTransform) -> MObject
Returns: MObject representing the new dependency node.

Arguments:
	[in]	parent = MObject
	[in]	UIvisible = bool
	[in]	wantTransform = bool


Creates a new spotlight dependency graph node and adds it to the dependency graph. If the UIvisible parameter is true, the new node will be connected to the light classification node (which allows the UI to recognize the node as a light) and added to the default light list. If UIvisible is false, the node will be created in isolation.'''
        pass

    def useDecayRegions(self): 
        '''useDecayRegions(self) -> bool
Returns: The value of the "useDecayRegions" attribute of the light node.


Retrieves the value of the "useDecayRegions" attribute of a light node. This attribute determines whether or not the light uses decay regions.'''
        pass

    def setDropOff(self, drop_off): 
        '''setDropOff(self, drop_off)
Arguments:
	[in]	drop_off = double


Sets the value of the "dropOff" attribute of a light node.'''
        pass

    def endDistance(self, which_region): 
        '''endDistance(self, which_region) -> float
Returns: The value of the appropriate endDistance attribute of the light node.

Arguments:
	[in]	which_region = MFnSpotLight.MDecayRegion


Retrieves the value of the end distance for the specified decay regions. The end distances for the spotlight's 3 decay regions are represented by the "endDistance1", "endDistance2", and "endDistance3" attributes. This function retrieves the value of the appropriate attribute.'''
        pass

    def coneAngle(self): 
        '''coneAngle(self) -> double
Returns: The value of the "coneAngle" attribute of the light node.


Retrieves the value of the "coneAngle" attribute of a light node. This attribute represents the angle that the spotlight cone makes with the spotlight direction vector.'''
        pass

    def className(self): 
        '''className(self) -> char*

'''
        pass

    def setEndDistance(self, which_region, end_distance): 
        '''setEndDistance(self, which_region, end_distance)
Arguments:
	[in]	which_region = MFnSpotLight.MDecayRegion
	[in]	end_distance = float


Sets the value of the appropriate decay region end distance attribute of a light node.'''
        pass

    def setBarnDoors(self, barn_doors): 
        '''setBarnDoors(self, barn_doors)
Arguments:
	[in]	barn_doors = bool


Sets the value of the "barnDoors" attribute of a light node.'''
        pass

    def setStartDistance(self, which_region, start_distance): 
        '''setStartDistance(self, which_region, start_distance)
Arguments:
	[in]	which_region = MFnSpotLight.MDecayRegion
	[in]	start_distance = float


Sets the value of the appropriate decay region start distance attribute of a light node.'''
        pass

    def setPenumbraAngle(self, penumbra_angle): 
        '''setPenumbraAngle(self, penumbra_angle)
Arguments:
	[in]	penumbra_angle = double


Sets the value of the "penumbraAngle" attribute of a light node.'''
        pass

    def barnDoors(self): 
        '''barnDoors(self) -> bool
Returns: The value of the "barnDoors" attribute of the light node.


Retrieves the value of the "barnDoors" attribute of a light node. This attribute determines whether or not the light uses barn doors.'''
        pass

    def startDistance(self, which_region): 
        '''startDistance(self, which_region) -> float
Returns: The value of the appropriate startDistance attribute of the light node.

Arguments:
	[in]	which_region = MFnSpotLight.MDecayRegion


Retrieves the value of the start distance for the specified decay regions. The start distances for the spotlight's 3 decay regions are represented by the "startDistance1", "startDistance2", and "startDistance3" attributes. This function retrieves the value of the appropriate attribute.'''
        pass

    def setUseDecayRegions(self, use_decay_regions): 
        '''setUseDecayRegions(self, use_decay_regions)
Arguments:
	[in]	use_decay_regions = bool


Sets the value of the "useDecayRegions" attribute of a light node.'''
        pass

    def type(self): 
        '''type(self) -> MFn.Type

'''
        pass

    def setConeAngle(self, cone_angle): 
        '''setConeAngle(self, cone_angle)
Arguments:
	[in]	cone_angle = double


Sets the value of the "coneAngle" attribute of a light node.'''
        pass

    def barnDoorAngle(self, which_door): 
        '''barnDoorAngle(self, which_door) -> double
Returns: The value of the appropriate barn door angle attribute of the light node.

Arguments:
	[in]	which_door = MFnSpotLight.MBarnDoor


Retrieves the value of the barn door angle for the specified barn door. The barn door angles are represented by the "leftBarnDoor", "rightBarnDoor", "topBarnDoor", and "bottomBarnDoor" attributes. This function retrieves the value of the appropriate attribute.'''
        pass

class MFnStringArrayData:
    '''String array function set for dependency node data. MFnStringArrayData allows the creation and manipulation of MStringArray data objects for use in the dependency graph.If a user written dependency node either accepts or produces MStringArrays, then this class is used to extract or create the data that comes from or goes to other dependency graph nodes. The MDataHandle::type method will return kStringArray when data of this type is present. To access it, the MDataHandle::data method is used to get an MObject for the data and this should then be used to initialize an instance of MFnStringArrayData. '''
    def __init__(self):
        pass


    def MString(self, index): 
        '''MString(self, index) -> const
Returns: The indicated MString 

Arguments:
	[in]	index = int


Extract the indicated  MString  from the const instance. No checking is done by this class to ensure that the index is valid - use the length method to determine the size of the array. If the instance is not attached to an  MObject , this method will return an  MString  containing "".'''
        pass

    def set(self, array): 
        '''set(self, array)
Arguments:
	[in]	array = MStringArray


Set the instance to contain the strings defined in the given  MStringArray .'''
        pass

    def create(self, arr): 
        '''create(self, arr) -> MObject
Returns: The newly created MObject 

Arguments:
	[in]	arr = MStringArray


Create a new  MObject , attach it to this instance, and initialize it to contain the data from the given  MStringArray .'''
        pass

    def copyTo(self, dest): 
        '''copyTo(self, dest)
Arguments:
	[out]	dest = MStringArray


Copy all the strings in the instance into the given  MStringArray .'''
        pass

    def className(self): 
        '''className(self) -> char*

'''
        pass

    def length(self): 
        '''length(self) -> int
Returns: The number of strings in the instance 


Return the number of strings in the instance.'''
        pass

    def array(self): 
        '''array(self) -> MStringArray
Returns: A copy of the MStringArray held in this instance 


Return an  MStringArray  containing the string array currently operated upon by the function set. The  MStringArray  returned by this method is editable, so any changes to the return instance also affects the  MObject  operated upon by this function set.'''
        pass

    def type(self): 
        '''type(self) -> MFn.Type

'''
        pass

class MFnStringData:
    '''String function set for dependency node data. MFnStringData allows the creation and manipulation of MString data objects for use in the dependency graph.If a user written dependency node either accepts or produces MString, then this class is used to extract or create the data that comes from or goes to other dependency graph nodes. The MDataHandle::type method will return kStringData when data of this type is present. To access it, the MDataHandle::data method is used to get an MObject for the data and this should then be used to initialize an instance of MFnStringData. '''
    def __init__(self):
        pass


    def className(self): 
        '''className(self) -> char*

'''
        pass

    def create(self): 
        '''create(self) -> MObject
Returns: The new MObject 


Create a new  MObject , attach it to this instance and initialize it to the null string.'''
        pass

    def set(self, string): 
        '''set(self, string)
Arguments:
	[in]	string = MString


Set this instance to hold a copy of the given string.'''
        pass

    def type(self): 
        '''type(self) -> MFn.Type

'''
        pass

    def string(self): 
        '''string(self) -> MString
Returns: An MString containing the string 


Return a copy of the string held in this instance.'''
        pass

class MFnSubd:
    '''Subdivision surface function set. This function set provides access to subdivision surfaces. Objects of type MFn::kSubdiv, MFn::kSubdivData, and MFn::kSubdivGeom are supported. MFn::kSubdiv objects are shapes in the DAG, MFn::kSubdivGeom objects are the raw geometry that the shapes use, and MFn::kSubdivData objects are the data that is passed through dependency graph connections.Maya implements fully hierarchical Catmull-Clark quad based subdivision surfaces. You can use them without any hierarchical edits, but their full power is only realized when you do use the hierarchy. Using the hierarchy lets you access additional vertices on the existing faces. For example, a single 4 vertex plane can give you access, through hierarchy, to over 16,000,000 points at the finest level of the hierarchy (please don't try it). Additionally, the points at the finer levels are created only as you need them and only in the areas where you need them, giving you an implied level of detail workflow.The "base" mesh is sometimes used to describe the coarsest level of the hierarchy. Once we go one level finer (to level "1") all faces are four sided (though not all vertices are of valence 4). At that point, each face can be considered to have 4 "children" faces. Starting with a 4 vertex single face plane, there will be 4 faces (and 9 vertices) at level 1, 16 faces (and 25 vertices) at level 2, etc. You can go as deep as level 12.Please consult Maya documentation on subdivision surfaces for more details. Subdivision surfaces are created by specifying a base polygonal mesh, hierarchical edits (optional) and creases (optional).The base mesh contains a vertex list, a list of vertex counts per-polygon, and a list of vertices that make up the polygons. If you are familiar with the creation of polygonal meshes, this is exactly equivalent to that setup. With a small set of limitations, any polygonal object can be converted into a subdivision surface. The current limitations are:The easiest way to create a subdivision surface is probably to use polyToSubdiv MEL command to create it from a polygon. Alternativelly, the same functionality is available through the API using  method.Alternatively, you can create a subdivision surface either by converting an existing NURBS surface with  or directly, by specifying vertex lists, vertex connections lists, etc. The last method will look familiar to those that have used  method to create a polygon.The following lists are used by the create method to construct a subdivision surface: You can optionally specify texture (uv) coordinates. UV coordinates are 2-d coordinates used for mapping textures to the polygons of a surface. Each polygon contains as many UV's as it has vertices. The UV values are not shared and you can think of them as "owned" by a polygon, rather than each vertex in that polygon.In order to successfully use the subdivision surface API, you need to familiarize yourself with the naming convention used for its components within the API.In the polygon case, we simply number the vertices 0, 1, ... N-1. The faces and the edges and the faces are numbered similarly.For the subdivision surfaces, this is not the case, mostly because of the hierarchical approach we took. Since it would be prohibitive to instantiate all the faces all the time (think of those 16M that can from just one original face) the names have to be order of creation independent.The simplest way to think about each API name is "start with a face and follow a path into the finer levels of the hierarchy recording each turn along the way".Here's some details. You should also consult  class which contains a number of helpful methods for interpreting, creating and modifying the component API names. While this will take some getting used to, the good news is that instantiating more vertices does not change the names of the existing ones (unless you're adding more level 0 vertices) so any vertex animation, etc. will not be affected by a need to model more detail into another part of the surface.For the subdivision surfaces, the most important names are those of the faces. Given a face name, each vertex on that face is named based on that face. That does mean that each vertex will typically have more than one name. Maya will always give you a unique name by choosing the one that is numerically the smallest (in the 64 bit sense). '''
    def __init__(self):
        pass


    def levelMaxCurrent(self): 
        '''levelMaxCurrent(self) -> int
Returns: The finest level in the hierarchy


Returns the finest level that currently exist. As int as a single face exists at a level, that level is counted. Note that this not mean that all of the faces exist on all levels.'''
        pass

    def vertexBaseMeshGetWithId(self, space, positions, vertexIds): 
        '''vertexBaseMeshGetWithId(self, space, positions, vertexIds)
Arguments:
	[out]	positions = MPointArray
	[out]	vertexIds = MUint64Array
	[in]	space = MSpace.Space


Return all base mesh vertices in the array using their indices but also provide the 64-bit names.'''
        pass

    def polygonCount(self, level): 
        '''polygonCount(self, level) -> int
Returns: The number of polygons at the specified level

Arguments:
	[in]	level = int


Returns the number of polygons currently existing at the specified level of the hierarchy.'''
        pass

    def getConnectedSetsAndMembers(self, instanceNumber, renderableSetsOnly, sets, comps): 
        '''getConnectedSetsAndMembers(self, instanceNumber, renderableSetsOnly, sets, comps)
Arguments:
	[in]	instanceNumber = int
	[out]	sets = MObjectArray
	[out]	comps = MObjectArray
	[in]	renderableSetsOnly = bool


Returns all the sets connected to the specified instance of this mesh. For each set in the "sets" array there is a corresponding entry in the "comps" array which are all the components in that set. If the entire object is in a set, then the corresponding entry in the comps array will have no elements in it.'''
        pass

    def updateAllEditsAndCreases(self): 
        '''updateAllEditsAndCreases(self)

If you have been editing offsets without updating the surface, this function will save you. This will dirty up the complete surface and recompute the positions of all the cvs, updating the crease info along the way. Not cheap to call.'''
        pass

    def levelMaxAllowed(self): 
        '''levelMaxAllowed(self) -> int
Returns: The maximum possibly value for the finest level in the hierarchy


Returns the maximum level that can be created. You should probably avoid fully subdividing the surface to that level as you will most likelly just run out of memory.'''
        pass

    def vertexBaseMeshAddWithIndex(self, x, y, z, index): 
        '''vertexBaseMeshAddWithIndex(self, x, y, z, index)
Arguments:
	[in]	x = double
	[in]	y = double
	[in]	z = double
	[in]	index = int


Very similar to vertexBaseMeshAdd, this gives you an advanced option of specifying the index for the new vertex to be created. You have to be extremelly careful to end up with the indices 0, 1, ... N-1 for N total vertices.'''
        pass

    def tessellateViaNurbs(self, parentOrOwner): 
        '''tessellateViaNurbs(self, parentOrOwner) -> MObject
Returns: If parentOrOwner is NULL then the transform for this surface is returned 
If parentOrOwner is a DAG object then the new surface shape is returned 
The surface geometry is returned if parentOrOwner is of type kMeshData

Arguments:
	[in]	parentOrOwner = MObject


Performs tesselation on this surface and create a new mesh in the DAG. The parentOrOwner argument is used to specify the owner of the new surface.'''
        pass

    def polygonGetCenterUV(self, polyId, u, v): 
        '''polygonGetCenterUV(self, polyId, u, v)
Arguments:
	[in]	polyId = MUint64
	[out]	u = double
	[out]	v = double


Return the UV values in the "center" of this polygon.'''
        pass

    def vertexEditsClearAllNonBase(self): 
        '''vertexEditsClearAllNonBase(self)

Find all vertices with edits and remove those edits, setting them back to their original position.'''
        pass

    def polygonBaseMeshAddWithUVs(self, vertexCount, vertexIds, uValues, vValues): 
        '''polygonBaseMeshAddWithUVs(self, vertexCount, vertexIds, uValues, vValues) -> MUint64

Arguments:
	[in]	vertexCount = int
	[in]	vertexIds = int
	[in]	uValues = double
	[in]	vValues = double


Add a polygon at the base mesh level. You will need to use the index names of the vertices (remember, they get their 64-bit names only after they have been added to a polygon). Specify the UV values as well.'''
        pass

    def evaluatePositionAndNormal(self, polyId, u, v, uvNormalized, pos, nrml): 
        '''evaluatePositionAndNormal(self, polyId, u, v, uvNormalized, pos, nrml)
Arguments:
	[in]	polyId = MUint64
	[in]	u = double
	[in]	v = double
	[in]	uvNormalized = bool
	[out]	pos = MPoint
	[out]	nrml = MVector


Evaluate the surface position and normal at the given parameter point on the polygon. The limitation is that this cannot be a base mesh polygon; i.e., it has to be at least level 1.'''
        pass

    def edgeIsCreased(self, edgeId): 
        '''edgeIsCreased(self, edgeId) -> bool
Returns: True if the edge is creased, false otherwise

Arguments:
	[in]	edgeId = MUint64


Return true if the edge is creased.'''
        pass

    def edgeSetCrease(self, edgeId, creased): 
        '''edgeSetCrease(self, edgeId, creased)
Arguments:
	[in]	edgeId = MUint64
	[in]	creased = bool


Set the particular edge's crease state.'''
        pass

    def vertexIncidentPolygons(self, vertexId, polyList): 
        '''vertexIncidentPolygons(self, vertexId, polyList)
Arguments:
	[in]	vertexId = MUint64
	[out]	polyList = MUint64Array


Return the list of incident polygons as their 64-bit ids.'''
        pass

    def convertToNurbs(self, newNurbsSurfaces): 
        '''convertToNurbs(self, newNurbsSurfaces)
Arguments:
	[out]	newNurbsSurfaces = MObjectArray


Converts this surface to a set of nurbs surfaces.'''
        pass

    def vertexIdFromBaseVertexIndex(self, baseVertexIndex): 
        '''vertexIdFromBaseVertexIndex(self, baseVertexIndex) -> MUint64
Returns: The 64-bit name of the vertex

Arguments:
	[in]	baseVertexIndex = int


Vertices are named using 64-bit integers. The base mesh vertices will also have a simple 0, 1, 2, N-1 indices. Use this function to compute the proper 64-bit name using the 0, 1, 2, ... indices.'''
        pass

    def vertexNormal(self, vertexId, normal): 
        '''vertexNormal(self, vertexId, normal)
Arguments:
	[in]	vertexId = MUint64
	[out]	normal = MVector


Returns the normal at the vertex'''
        pass

    def copy(self, source, parentOrOwner): 
        '''copy(self, source, parentOrOwner) -> MObject
Returns: If parentOrOwner is NULL then the transform for this surface is returned 
If parentOrOwner is a DAG object then the new surface shape is returned 
The surface geometry is returned if parentOrOwner is of type kSubdivData

Arguments:
	[in]	source = MObject
	[in]	parentOrOwner = MObject


This method creates a copy of a given source subdivision surface. After the copy this function set will operate on the new subdivision surface.'''
        pass

    def vertexBaseMeshGet(self, space, positions): 
        '''vertexBaseMeshGet(self, space, positions)
Arguments:
	[out]	positions = MPointArray
	[in]	space = MSpace.Space


Return all base mesh vertices in the array using their indices (not the 64-bit names).'''
        pass

    def evaluatePosition(self, polyId, u, v, uvNormalized, pos): 
        '''evaluatePosition(self, polyId, u, v, uvNormalized, pos)
Arguments:
	[in]	polyId = MUint64
	[in]	u = double
	[in]	v = double
	[in]	uvNormalized = bool
	[out]	pos = MPoint


Evaluate the surface position at the given parameter point on the polygon. The limitation is that this cannot be a base mesh polygon; i.e., it has to be at least level 1.'''
        pass

    def vertexIsCreased(self, vertexId): 
        '''vertexIsCreased(self, vertexId) -> bool
Returns: Whether the vertex is creased or not

Arguments:
	[in]	vertexId = MUint64


Return true if the vertex is creased.'''
        pass

    def vertexEditGet(self, vertexId, space, edit): 
        '''vertexEditGet(self, vertexId, space, edit)
Arguments:
	[in]	vertexId = MUint64
	[out]	edit = MVector
	[in]	space = MSpace.Space


Get the offset of the specified vertex from its original position. This vector really is  vertexPositionGet()  -  vertexPositionGetNoEdit() .'''
        pass

    def levelFullySubdivideTo(self, level): 
        '''levelFullySubdivideTo(self, level)
Arguments:
	[in]	level = int


Fully subdivide the whole surface to the specified level. This could be very expensive, so be careful, or you will run out of memory. As a rule, each level has 4 times more faces than the previous one.'''
        pass

    def edgeBetween(self, vertex1, vertex2): 
        '''edgeBetween(self, vertex1, vertex2) -> MUint64
Returns: The name of the edge between the two

Arguments:
	[in]	vertex1 = MUint64
	[in]	vertex2 = MUint64


Return the name of the edge that connects the two vertices. If the edge doesn't exist, it will be created.'''
        pass

    def vertexBaseIndexFromVertexId(self, vertexId): 
        '''vertexBaseIndexFromVertexId(self, vertexId) -> int
Returns: The index in the base mesh vertex array of this vertex

Arguments:
	[in]	vertexId = MUint64


Given a 64-bit id of the vertex, return its index (0, 1, ...) if it happens to be a base mesh vertex. It is an error to call this function with a non base mesh vertex.'''
        pass

    def polygonEdgeCount(self, polyId): 
        '''polygonEdgeCount(self, polyId) -> int
Returns: The number of edges on this polygon

Arguments:
	[in]	polyId = MUint64


The number of edges on the given polygon.'''
        pass

    def edgeIsBoundary(self, edgeId): 
        '''edgeIsBoundary(self, edgeId) -> bool
Returns: True if the edge is a boundary edge, false otherwise.

Arguments:
	[in]	edgeId = MUint64


Test if the edge specified is a boundary edge or not.'''
        pass

    def vertexCreaseRelevant(self, vertexId): 
        '''vertexCreaseRelevant(self, vertexId) -> bool
Returns: Whether the vertex has relevant crease information

Arguments:
	[in]	vertexId = MUint64


Return true if the crease of the vertex is a relevant piece of information. The vertex inherits the crease state from its parent. So, its crease state is relevant only if different from its parent (or if there is no direct parent vertex).'''
        pass

    def edgeAdjacentPolygon(self, edgeId, polys): 
        '''edgeAdjacentPolygon(self, edgeId, polys)
Arguments:
	[in]	edgeId = MUint64
	[out]	polys = MUint64Array


Return the polygons adjacent to this edge. There can be at most two, as non-manifold topology is not allowed.'''
        pass

    def evaluateNormal(self, polyId, u, v, uvNormalized, nrml): 
        '''evaluateNormal(self, polyId, u, v, uvNormalized, nrml)
Arguments:
	[in]	polyId = MUint64
	[in]	u = double
	[in]	v = double
	[in]	uvNormalized = bool
	[out]	nrml = MVector


Evaluate the surface normal at the given parameter point on the polygon. The limitation is that this cannot be a base mesh polygon; i.e., it has to be at least level 1.'''
        pass

    def vertexIsBoundary(self, vertexId): 
        '''vertexIsBoundary(self, vertexId) -> bool
Returns: Whether the vertex is boundary or not

Arguments:
	[in]	vertexId = MUint64


Return true if the vertex is a boundary vertex.'''
        pass

    def polygonChildren(self, polyId, children): 
        '''polygonChildren(self, polyId, children)
Arguments:
	[in]	polyId = MUint64
	[out]	children = MUint64Array


Returns the list of children polygons on the given polygon. If the children array is not empty, we will just append to it.'''
        pass

    def vertexEditSet(self, vertexId, edit, updateEdits, space): 
        '''vertexEditSet(self, vertexId, edit, updateEdits, space)
Arguments:
	[in]	vertexId = MUint64
	[in]	edit = MVector
	[in]	updateEdits = bool
	[in]	space = MSpace.Space


Set the original position offset for the given vertex.'''
        pass

    def type(self): 
        '''type(self) -> MFn.Type

'''
        pass

    def polygonBaseMeshAdd(self, vertexCount, vertexIndex): 
        '''polygonBaseMeshAdd(self, vertexCount, vertexIndex) -> MUint64
Returns: The name of the newly created polygon

Arguments:
	[in]	vertexCount = int
	[in]	vertexIndex = int


Add a polygon at the base mesh level. You will need to use the index names of the vertices (remember, they get their 64-bit names only after they have been added to a polygon).'''
        pass

    def getConnectedShaders(self, instanceNumber, shaders, faces, indices): 
        '''getConnectedShaders(self, instanceNumber, shaders, faces, indices)
Arguments:
	[in]	instanceNumber = int
	[out]	shaders = MObjectArray
	[out]	faces = MUint64Array
	[out]	indices = MIntArray


Returns all the shaders (sets) connected to the specified instance of this subdivision surface and two arrays indicating face/shader assignments. For each face in the face array, there is a corresponding entry in the indices array to indicate the assigned shader in the shader array.'''
        pass

    def edgeIsValid(self, edgeId): 
        '''edgeIsValid(self, edgeId) -> bool
Returns: True if the edge name is valid, false otherwise.

Arguments:
	[in]	edgeId = MUint64


Returns true if the specified edge name is valid.'''
        pass

    def vertexIsValid(self, vertexId): 
        '''vertexIsValid(self, vertexId) -> bool
Returns: Whether the vertex is valid or not. Valid means that the vertex has been instantiated on the surface. Not all vertices at all levels exist by default. A vertex only exists if it was created at the time the subdiv was first created or if the subdiv was refined.

Arguments:
	[in]	vertexId = MUint64


Return true if the vertex is a valid vertex.'''
        pass

    def polygonCountMaxWithGivenBaseMesh(self, level): 
        '''polygonCountMaxWithGivenBaseMesh(self, level) -> int
Returns: The number of polygons at the given level if you were to fully subdivide at that level.

Arguments:
	[in]	level = int


If you were to fully subdivide at a given level, how many polygons would you have at that level? This function will tell you and possibly save you from running out of memory if you go too deep. Note that this is exactly the same as "polygonCount" for levels 0 and 1.'''
        pass

    def vertexPositionSet(self, vertexId, updateEdits, space, position): 
        '''vertexPositionSet(self, vertexId, updateEdits, space, position)
Arguments:
	[in]	vertexId = MUint64
	[out]	position = MPoint
	[in]	updateEdits = bool
	[in]	space = MSpace.Space


Set the position of the vertex with a given name.'''
        pass

    def collapse(self, level, makeNewNodeInvisible): 
        '''collapse(self, level, makeNewNodeInvisible) -> MObject
Returns: The new collapsed subdivision object

Arguments:
	[in]	level = int
	[in]	makeNewNodeInvisible = bool


This method creates a copy of a given source subdivision surface collapsed by the given number of levels. After the collapse this function set will operate on the new subdivision surface.'''
        pass

    def createBaseMesh(self, reverseNormal, numVertices, numPolygons, vertexArray, polygonCounts, polygonConnects, parentOrOwner): 
        '''createBaseMesh(self, reverseNormal, numVertices, numPolygons, vertexArray, polygonCounts, polygonConnects, parentOrOwner) -> MObject

Arguments:
	[in]	reverseNormal = bool
	[in]	numVertices = int
	[in]	numPolygons = int
	[in]	vertexArray = MPointArray
	[in]	polygonCounts = MIntArray
	[in]	polygonConnects = MIntArray
	[in]	parentOrOwner = MObject


Creates a new subdivision surface given an array of vertices and connection information and sets this function set to operate on the new surface.'''
        pass

    def editsPending(self): 
        '''editsPending(self) -> int
Returns: Edits pending (1) or not (0).


As the new hierarchical vertex offsets are being introduced, you can choose to not apply them to the surface immediatelly. If you do that, the number of edits pending will increase. Any edits are not actually made until you call "updateEdits". This functions lets you know if you need to call it or not.'''
        pass

    def vertexEditsSetAllNonBase(self, vertexIds, edits, space): 
        '''vertexEditsSetAllNonBase(self, vertexIds, edits, space)
Arguments:
	[in]	vertexIds = MUint64Array
	[in]	edits = MVectorArray
	[in]	space = MSpace.Space


Given an array of vertex names and the offsets from their original positions, set the new vertex positions.'''
        pass

    def vertexChildren(self, vertexId, children): 
        '''vertexChildren(self, vertexId, children)
Arguments:
	[in]	vertexId = MUint64
	[out]	children = MUint64Array


Returns the "children" of the particular vertex if they exist. The children are defined as the finer-level version of the current vertex plus the neighbors of that vertex. For a valence n vertex this means 2n+1 vertices are returned if a finer level exists.'''
        pass

    def vertexEditsGetAllNonBase(self, vertexIds, edits, space): 
        '''vertexEditsGetAllNonBase(self, vertexIds, edits, space)
Arguments:
	[in]	vertexIds = MUint64Array
	[in]	edits = MVectorArray
	[in]	space = MSpace.Space


Returns all the vertices below the base mesh that have been modified from their original position (the original position is specified by the position of the base mesh vertices). The two arrays will be of the same length upon return. Length 0 would suggest that there have been no edits from the original positions.'''
        pass

    def edgeCreaseRelevant(self, edgeId): 
        '''edgeCreaseRelevant(self, edgeId) -> bool
Returns: Whether the edge has relevant crease information

Arguments:
	[in]	edgeId = MUint64


Return true if the crease of the edge is a relevant piece of information. The edge inherits the crease state from its parent. So, its crease state is relevant only if different from its parent (or if there is no direct parent edge).'''
        pass

    def polygonVertices(self, polyId, vertexIds): 
        '''polygonVertices(self, polyId, vertexIds)
Arguments:
	[in]	polyId = MUint64
	[out]	vertexIds = MUint64Array


Given the polygon, return its vertices. The vertices are at the same level as the polygon.'''
        pass

    def polygonGetVertexUVs(self, polyId, uValues, vValues): 
        '''polygonGetVertexUVs(self, polyId, uValues, vValues)
Arguments:
	[in]	polyId = MUint64
	[out]	uValues = MDoubleArray
	[out]	vValues = MDoubleArray


Get the vertex UVs from the polygon. The values come back in exactly the same order as the polygon vertices do.'''
        pass

    def vertexValence(self, vertexId): 
        '''vertexValence(self, vertexId) -> int
Returns: The finest level in the hierarchy

Arguments:
	[in]	vertexId = MUint64


Returns the valence (number of incident edges) of the given vertex.'''
        pass

    def vertexCount(self, level): 
        '''vertexCount(self, level) -> int
Returns: The number of vertices at the given level

Arguments:
	[in]	level = int


Returns the finest vertex count at a particular level. These are the vertices that are currently instantiated.'''
        pass

    def polygonHasVertexUVs(self, polyId): 
        '''polygonHasVertexUVs(self, polyId) -> bool
Returns: True if there were explicitly specified UVs on this polygon.

Arguments:
	[in]	polyId = MUint64


Returns true if there are user specified UVs on this polygon.'''
        pass

    def tesselate(self, uniform, depth, sample, parentOrOwner): 
        '''tesselate(self, uniform, depth, sample, parentOrOwner) -> MObject
Returns: If parentOrOwner is NULL then the transform for this surface is returned 
If parentOrOwner is a DAG object then the new surface shape is returned 
The surface geometry is returned if parentOrOwner is of type kMeshData

Arguments:
	[in]	uniform = bool
	[in]	depth = int
	[in]	sample = int
	[in]	parentOrOwner = MObject


Performs tesselation on this surface and create a new mesh in the DAG. The parentOrOwner argument is used to specify the owner of the new surface.'''
        pass

    def creasesGetAll(self, vertexIds, edgeIds): 
        '''creasesGetAll(self, vertexIds, edgeIds)
Arguments:
	[out]	vertexIds = MUint64Array
	[out]	edgeIds = MUint64Array


Returns all creases on the subdivision surface in two arrays of 64-bit ids; one for the vertices, one for edges.'''
        pass

    def getCubicSpline(self, polyId, vertices): 
        '''getCubicSpline(self, polyId, vertices) -> bool
Returns: True if we can make the conversion, false otherwise

Arguments:
	[in]	polyId = MUint64
	[out]	vertices = MPointArray


Some of the faces (usually at level 2 or below) happen to be exactly the same as uniform bi-cubic B-splines. This routine will return the 16 points that define such spline.'''
        pass

    def vertexPositionGetNoEdit(self, vertexId, space, position): 
        '''vertexPositionGetNoEdit(self, vertexId, space, position)
Arguments:
	[in]	vertexId = MUint64
	[out]	position = MPoint
	[in]	space = MSpace.Space


What would the position of this vertex be if there were no edits; i.e., what was its original position.'''
        pass

    def polygonSetUseUVs(self, polyId, useThem): 
        '''polygonSetUseUVs(self, polyId, useThem)
Arguments:
	[in]	polyId = MUint64
	[in]	useThem = bool


If this is set, the polygon will use the user specified UVs.'''
        pass

    def updateSubdSurface(self): 
        '''updateSubdSurface(self)

Signal that this subdivision surface has changed and needs to redraw itself.'''
        pass

    def polygonEdges(self, polyId, edgeIds): 
        '''polygonEdges(self, polyId, edgeIds)
Arguments:
	[in]	polyId = MUint64
	[out]	edgeIds = MUint64Array


Given the polygon, return its edges. The edges are at the same level as the polygon.'''
        pass

    def vertexBaseMeshSet(self, space, positions): 
        '''vertexBaseMeshSet(self, space, positions)
Arguments:
	[out]	positions = MPointArray
	[in]	space = MSpace.Space


Set the positions for the base mesh vertices using the 0, 1,... indexing instead of the 64-bit vertex names.'''
        pass

    def creasesSetAll(self, vertexIds, edgeIds): 
        '''creasesSetAll(self, vertexIds, edgeIds)
Arguments:
	[in]	vertexIds = MUint64Array
	[in]	edgeIds = MUint64Array


Set the creases on all vertices and edges with a given 64-bit name. Note that the combination of  creasesGetAll()  and  creasesSetAll()  will not exactly duplicate the crease information between two surfaces.'''
        pass

    def edgeCount(self, level): 
        '''edgeCount(self, level) -> int
Returns: Number of edges at the given level

Arguments:
	[in]	level = int


Returns the number of edges at a level.'''
        pass

    def edgeVertices(self, edgeId, v1, v2): 
        '''edgeVertices(self, edgeId, v1, v2)
Arguments:
	[in]	edgeId = MUint64
	[out]	v1 = MUint64
	[out]	v2 = MUint64


Given an edge, return the two vertices at its ends.'''
        pass

    def creasesClearAll(self): 
        '''creasesClearAll(self)

Clear all crease information from this surface. No vertices or edges will be creased after this function completes.'''
        pass

    def vertexPositionGet(self, vertexId, space, position): 
        '''vertexPositionGet(self, vertexId, space, position)
Arguments:
	[in]	vertexId = MUint64
	[out]	position = MPoint
	[in]	space = MSpace.Space


Get the position of the vertex with a given name.'''
        pass

    def edgeChildren(self, edgeId, children): 
        '''edgeChildren(self, edgeId, children)
Arguments:
	[in]	edgeId = MUint64
	[out]	children = MUint64Array


Returns the "children" of the particular edge. If the edge has children, there will always be two child edges.'''
        pass

    def polygonSetVertexUVs(self, polyId, uValues, vValues): 
        '''polygonSetVertexUVs(self, polyId, uValues, vValues)
Arguments:
	[in]	polyId = MUint64
	[in]	uValues = MDoubleArray
	[in]	vValues = MDoubleArray


Set the UV values on the polygon.'''
        pass

    def polygonSubdivide(self, polyId): 
        '''polygonSubdivide(self, polyId)
Arguments:
	[in]	polyId = MUint64


Subdivide the given polygon into 4 children (if this happens to be the level 0 polygon you will get as many children as that polygon has edges).'''
        pass

    def className(self): 
        '''className(self) -> char*

'''
        pass

    def vertexBaseMeshAdd(self, x, y, z): 
        '''vertexBaseMeshAdd(self, x, y, z) -> int
Returns: The index of the newly created vertex. It will be -1 if the creation failed.

Arguments:
	[in]	x = double
	[in]	y = double
	[in]	z = double


Add a vertex to the base mesh and return its "index" name. Note that it will not have a valid 64-bit name until you actually create a polygon that holds it.'''
        pass

    def polygonVertexCount(self, polyId): 
        '''polygonVertexCount(self, polyId) -> int
Returns: The number of vertices on this polygon

Arguments:
	[in]	polyId = MUint64


How many vertices on a given polygon? The vertices are at the same level as the polygon.'''
        pass

    def vertexSetCrease(self, vertexId, creased): 
        '''vertexSetCrease(self, vertexId, creased)
Arguments:
	[in]	vertexId = MUint64
	[in]	creased = bool


Set the particular vertex' crease state.'''
        pass

    def polygonHasChildren(self, polyId): 
        '''polygonHasChildren(self, polyId) -> bool
Returns: Whether the polygon has children.

Arguments:
	[in]	polyId = MUint64


Returns whether or not the given polygon has children.'''
        pass

    def vertexBaseMeshSetWithId(self, space, positions, vertexIds): 
        '''vertexBaseMeshSetWithId(self, space, positions, vertexIds)
Arguments:
	[out]	positions = MPointArray
	[out]	vertexIds = MUint64Array
	[in]	space = MSpace.Space


Set the positions for the base mesh vertices using the 64-bit names. The ordering of the elements in the array is irrelevant. The edits will be automatically updated (i.e.,  editsPending()  will return 0 after the call to this function).'''
        pass

    def editsUpdateAll(self): 
        '''editsUpdateAll(self)

If there are pending edits, this function will update the surface so that there are no pending edits.'''
        pass

    def vertexIncidentEdges(self, vertexId, edgeList): 
        '''vertexIncidentEdges(self, vertexId, edgeList)
Arguments:
	[in]	vertexId = MUint64
	[out]	edgeList = MUint64Array


Return the list of incident edges as their 64-bit ids.'''
        pass

    def polygonIsValid(self, polygonId): 
        '''polygonIsValid(self, polygonId) -> bool
Returns: Whether the polygon is valid or not. Valid means that the polygon has been instantiated on the surface. Not all polygons at all levels exist by default. A polygon only exists if it was created at the time the subdiv was first created or if the subdiv was refined.

Arguments:
	[in]	polygonId = MUint64


Return true if the polygon is a valid polygon.'''
        pass

    def vertexAdjacentVertices(self, vertexId, vertList): 
        '''vertexAdjacentVertices(self, vertexId, vertList)
Arguments:
	[in]	vertexId = MUint64
	[out]	vertList = MUint64Array


Return the list of adjacent vertices as their 64-bit ids.'''
        pass

class MFnSubdData:
    '''Subdiv Surface function set for dependency node data. MFnSubdData allows the creation and manipulation of Subdivision Surface data objects for use in the dependency graph.If a user written dependency node either accepts or produces Subdivision Surfaces, then this class is used to extract or create the data that comes from or goes to other dependency graph nodes. The MDataHandle::type method will return kSubdiv when data of this type is present.If a node is receiving a Subdivision Surface via an input attribute, the asSubdSurface method of MDataHandle can be used to access that input Subdivision Surface.If a node is to create a Subdivision Surface and send it via an output attribute, a new MFnSubdData must be instantiated and then the create method called to build the actual data block as an MObject. This MObject should be passed to the MFnSubd::create method as the parentOrOwner parameter so that the Subdivision Surface will be constructed inside the data block. The MDataHandle::set routine is then used to pass the data block down the connection. '''
    def __init__(self):
        pass


    def className(self): 
        '''className(self) -> char*

'''
        pass

    def create(self): 
        '''create(self) -> MObject
Returns: The new MObject 


Create a new  MObject , attach it to this instance and initialize it with a data block capable of holding a Subdivision Surface.'''
        pass

    def type(self): 
        '''type(self) -> MFn.Type

'''
        pass

class MFnSubdNames:
    '''Manipulate Subdivision Surface vertex, edge and face ids. This function set provides some simple utilities for the interpretation and manipulation of the subdivision surface vertex, edge and face ids. '''
    def __init__(self):
        pass


    def levelOneFaceIdFromIndex(self, index): 
        '''levelOneFaceIdFromIndex(self, index) -> MUint64

Arguments:
	[in]	index = int


Given a level 1 face name as integer, return it as a 64-bit name.'''
        pass

    def nonBaseFaceEdges(self, id, edge1, edge2, edge3, edge4): 
        '''nonBaseFaceEdges(self, id, edge1, edge2, edge3, edge4)
Arguments:
	[in]	id = MUint64
	[in]	edge1 = MUint64
	[in]	edge2 = MUint64
	[in]	edge3 = MUint64
	[in]	edge4 = MUint64


Return the four edges on the given face. Note that the face should not be a base mesh face (the level > 0).'''
        pass

    def level(self, id): 
        '''level(self, id) -> int

Arguments:
	[in]	id = MUint64


Given a 64-bit name, return the level of the component'''
        pass

    def fromMUint64(self, id, base, first, level, path, corner): 
        '''fromMUint64(self, id, base, first, level, path, corner)
Arguments:
	[in]	id = MUint64
	[out]	base = int
	[out]	first = int
	[out]	level = int
	[out]	path = int
	[out]	corner = int


Given a 64-bit name, compute the base face, first level face index, level, path to the face and the corner choice at the finest face.'''
        pass

    def toSelectionIndices(self, id, firstIndex, secondIndex): 
        '''toSelectionIndices(self, id, firstIndex, secondIndex)
Arguments:
	[in]	id = MUint64
	[out]	firstIndex = int
	[out]	secondIndex = int


Given a 64-bit name, return the two integers that will show up as selection indices for that subd component.'''
        pass

    def levelOneFaceIndexFromId(self, id): 
        '''levelOneFaceIndexFromId(self, id) -> int

Arguments:
	[in]	id = MUint64


Given a 64-bit name, return the level one mesh face as an integer, instead of 64-bit name.'''
        pass

    def levelOneFaceId(self, id): 
        '''levelOneFaceId(self, id) -> MUint64

Arguments:
	[in]	id = MUint64


Given a 64-bit name, return the level one face that is the parent for the given component.'''
        pass

    def baseFaceId(self, id): 
        '''baseFaceId(self, id) -> MUint64

Arguments:
	[in]	id = MUint64


Given a 64-bit name, return the 64-bit name of the base face that is the parent of the given component.'''
        pass

    def base(self, id): 
        '''base(self, id) -> int

Arguments:
	[in]	id = MUint64


Given a 64-bit name, return the base mesh face.'''
        pass

    def baseFaceIndexFromId(self, id): 
        '''baseFaceIndexFromId(self, id) -> int

Arguments:
	[in]	id = MUint64


Same as base().'''
        pass

    def nonBaseFaceVertices(self, id, vertex1, vertex2, vertex3, vertex4): 
        '''nonBaseFaceVertices(self, id, vertex1, vertex2, vertex3, vertex4)
Arguments:
	[in]	id = MUint64
	[in]	vertex1 = MUint64
	[in]	vertex2 = MUint64
	[in]	vertex3 = MUint64
	[in]	vertex4 = MUint64


Return the four vertices on the given face. Note that the face should not be a base mesh face (the level > 0).'''
        pass

    def baseFaceIdFromIndex(self, index): 
        '''baseFaceIdFromIndex(self, index) -> MUint64

Arguments:
	[in]	index = int


Given the index of the base face (0, 1, ... N-1), return its 64-bit name.'''
        pass

    def corner(self, id): 
        '''corner(self, id) -> int

Arguments:
	[in]	id = MUint64


One of the 4 possible choices of the vertex or an edge once we're at the particular face.'''
        pass

    def fromSelectionIndices(self, id, firstIndex, secondIndex): 
        '''fromSelectionIndices(self, id, firstIndex, secondIndex)
Arguments:
	[in]	id = MUint64
	[in]	firstIndex = int
	[in]	secondIndex = int


Given the two integers that would show as selection indices for the subd component, return the 64-bit name for that component.'''
        pass

    def path(self, id): 
        '''path(self, id) -> int

Arguments:
	[in]	id = MUint64


Given a 64-bit name, return from level 1 face down to the face in question. Two bits per level for the four possible choices.'''
        pass

    def parentFaceId(self, id): 
        '''parentFaceId(self, id) -> MUint64

Arguments:
	[in]	id = MUint64


Given a 64-bit name of the face, return its parent face id. Note that if the given face id is from a base face (ie. it is a face at level 0), the returned face will be exactly the same.'''
        pass

    def toMUint64(self, id, base, first, level, path, corner): 
        '''toMUint64(self, id, base, first, level, path, corner)
Arguments:
	[in]	id = MUint64
	[in]	base = int
	[in]	first = int
	[in]	level = int
	[in]	path = int
	[in]	corner = int


Compute the 64-bit name given the base face index, first level face index, level, path to the finest face and the corner choice. The corner is zero (ignore) if the component is to be the face.'''
        pass

    def first(self, id): 
        '''first(self, id) -> int

Arguments:
	[in]	id = MUint64


Given a 64-bit name, return the index of the first child of the base face.'''
        pass

class MFnTransform:
    '''Create and access transform nodes. The MFnTransform function set provides access to transformation DAG nodes called transforms.DAG nodes are separated into two types, transforms and geometry nodes. All DAG nodes that are not transform nodes must exist as a child of a transform node. Only transforms provide transformation information. Transforms are also commonly used as parent nodes for the purpose of hierarchical grouping.The transformation in the node is represented as a 4x4 transformation matrix. This function set allows access to the whole matrix, or the individual components (eg scale, rotation, shear, etc) of the transformation. The transform node is made up of many components that make up the final transformation matrix. This breakdown provides animators fine control over the animation of these parameters. Therefore, it is necessary to describe the order in which these attributes are applied to build the final matrix attribute.A transformation matrix is composed of the following components, all components with units will be in maya's internal units (radians for rotations and centimeters for translations):The matrices are post-multiplied in Maya. For example, to transform a point P from object-space to world-space (P') you would need to post-multiply by the worldMatrix. (P' = P x WM)The transformation matrix is then constructed as follows:where 'x' denotes matrix multiplication and '-1' denotes matrix inversionNote that internally the Maya transform does not store the individual component values in matrices. It stores them in the data structure which makes the most sense for that component. For example, translation is stored as a vector. The accessor methods on MFnTransform provide the data in their native structure rather than as a matrix.Additionally, each transform can save a temporary "rest position" matrix using the setRestPosition method. The rest position is not used internally by Maya. It is exclusively for use from the API as a temporary cache, which can be set and restored within a single Maya session. Note that the rest position is not saved with the scene. '''
    def __init__(self):
        pass


    def set(self, transform): 
        '''set(self, transform)
Arguments:
	[in]	transform = MTransformationMatrix


Change this transform to equal the given matrix.'''
        pass

    def scalePivot(self, space): 
        '''scalePivot(self, space) -> MPoint
Returns: Scale pivot point in centimeters

Arguments:
	[in]	space = MSpace.Space


Returns the pivot around which the scale is applied. The pivot will be in centimeters.'''
        pass

    def translateBy(self, vector, space): 
        '''translateBy(self, vector, space)
Arguments:
	[in]	vector = MVector
	[in]	space = MSpace.Space


Relatively change the translation component of this transformation.'''
        pass

    def kShearMaxYZ(self):
        '''This is an enum of LimitType.
Description: 
Value: 11'''
        pass

    def kScaleMaxZ(self):
        '''This is an enum of LimitType.
Description: 
Value: 5'''
        pass

    def kScaleMaxY(self):
        '''This is an enum of LimitType.
Description: 
Value: 3'''
        pass

    def kScaleMaxX(self):
        '''This is an enum of LimitType.
Description: 
Value: 1'''
        pass

    def kShearMinYZ(self):
        '''This is an enum of LimitType.
Description: 
Value: 10'''
        pass

    def kTranslateMinX(self):
        '''This is an enum of LimitType.
Description: 
Value: 18'''
        pass

    def kTranslateMinZ(self):
        '''This is an enum of LimitType.
Description: 
Value: 22'''
        pass

    def kTranslateMaxZ(self):
        '''This is an enum of LimitType.
Description: 
Value: 23'''
        pass

    def kTranslateMaxY(self):
        '''This is an enum of LimitType.
Description: 
Value: 21'''
        pass

    def kTranslateMaxX(self):
        '''This is an enum of LimitType.
Description: 
Value: 19'''
        pass

    def kTranslateMinY(self):
        '''This is an enum of LimitType.
Description: 
Value: 20'''
        pass

    def kScaleMinY(self):
        '''This is an enum of LimitType.
Description: 
Value: 2'''
        pass

    def kScaleMinX(self):
        '''This is an enum of LimitType.
Description: 
Value: 0'''
        pass

    def kScaleMinZ(self):
        '''This is an enum of LimitType.
Description: 
Value: 4'''
        pass

    def kShearMaxXZ(self):
        '''This is an enum of LimitType.
Description: 
Value: 9'''
        pass

    def kShearMaxXY(self):
        '''This is an enum of LimitType.
Description: 
Value: 7'''
        pass

    def kRotateMaxZ(self):
        '''This is an enum of LimitType.
Description: 
Value: 17'''
        pass

    def kRotateMaxY(self):
        '''This is an enum of LimitType.
Description: 
Value: 15'''
        pass

    def kRotateMaxX(self):
        '''This is an enum of LimitType.
Description: 
Value: 13'''
        pass

    def kShearMinXY(self):
        '''This is an enum of LimitType.
Description: 
Value: 6'''
        pass

    def kShearMinXZ(self):
        '''This is an enum of LimitType.
Description: 
Value: 8'''
        pass

    def kRotateMinY(self):
        '''This is an enum of LimitType.
Description: 
Value: 14'''
        pass

    def kRotateMinX(self):
        '''This is an enum of LimitType.
Description: 
Value: 12'''
        pass

    def kRotateMinZ(self):
        '''This is an enum of LimitType.
Description: 
Value: 16'''
        pass

    class LimitType:
        '''Non-functional class.  Values for this enum:
        kShearMaxYZ
        kScaleMaxZ
        kScaleMaxY
        kScaleMaxX
        kShearMinYZ
        kTranslateMinX
        kTranslateMinZ
        kTranslateMaxZ
        kTranslateMaxY
        kTranslateMaxX
        kTranslateMinY
        kScaleMinY
        kScaleMinX
        kScaleMinZ
        kShearMaxXZ
        kShearMaxXY
        kRotateMaxZ
        kRotateMaxY
        kRotateMaxX
        kShearMinXY
        kShearMinXZ
        kRotateMinY
        kRotateMinX
        kRotateMinZ
'''
        def __init__(self):
            pass

    def getTranslation(self, space): 
        '''getTranslation(self, space) -> MVector
Returns: Translation vector in centimeters

Arguments:
	[in]	space = MSpace.Space


Retrieve the translation component of this transformation in centimeters.'''
        pass

    def getRotation(self, rotation, order): 
        '''getRotation(self, rotation, order)
Arguments:
	[out]	rotation = double3
	[out]	order = MTransformationMatrix.RotationOrder


Retrieve the rotation component of this transformation. The rotation is retrieved in  MSpace::kTransform  space.'''
        pass

    def getShear(self, shear): 
        '''getShear(self, shear)
Arguments:
	[out]	shear = double3


Retrieve the shearing component of this transformation.'''
        pass

    def setRotatePivotTranslation(self, vector, space): 
        '''setRotatePivotTranslation(self, vector, space)
Arguments:
	[in]	vector = MVector
	[in]	space = MSpace.Space


Set the rotate pivot translation in centimeters. This component is used internally by maya when the user moves the rotate pivot, or when the balance flag is true in the  MFnTransform::setRotatePivot  method. It serves as a compensation that allows existing transformations to be preserved when the rotate pivot is modified. For the precise mathematics, refer to the transformation matrix details in the description section of  MFnTransform .'''
        pass

    def rotateOrientation(self, space): 
        '''rotateOrientation(self, space) -> MQuaternion
Returns: Rotateorientation

Arguments:
	[in]	space = MSpace.Space


Returns the rotation used to orient the local rotation space. For the precise mathematics, refer to the transformation matrix details in the description section of  MFnTransform .'''
        pass

    def setScalePivot(self, point, space, balance): 
        '''setScalePivot(self, point, space, balance)
Arguments:
	[in]	point = MPoint
	[in]	space = MSpace.Space
	[in]	balance = bool


Set the pivot around which the scale is applied in centimeters.'''
        pass

    def rotateByQuaternion(self, x, y, z, w, space): 
        '''rotateByQuaternion(self, x, y, z, w, space)
Arguments:
	[in]	x = double
	[in]	y = double
	[in]	z = double
	[in]	w = double
	[in]	space = MSpace.Space


Relatively change the rotation of this transformation using a quaternion.'''
        pass

    def shearBy(self, shear): 
        '''shearBy(self, shear)
Arguments:
	[in]	shear = double3


Relatively shear this transformation.'''
        pass

    def create(self, parent): 
        '''create(self, parent) -> MObject
Returns: The newly created transform node object

Arguments:
	[in]	parent = MObject


Creates a new transformation node. The new node is placed in the DAG.'''
        pass

    def rotatePivot(self, space): 
        '''rotatePivot(self, space) -> MPoint
Returns: Rotation pivot point in centimeters

Arguments:
	[in]	space = MSpace.Space


Returns the pivot about which the rotation is applied.'''
        pass

    def restPosition(self): 
        '''restPosition(self) -> MTransformationMatrix
Returns: The transformation matrix equivalent to the transform's rest position. This rest position will be identity unless the "setRestPosition" method has been called.


Retrieve the saved rest position of this transform.'''
        pass

    def rotatePivotTranslation(self, space): 
        '''rotatePivotTranslation(self, space) -> MVector
Returns: Scale pivot translation in centimeters

Arguments:
	[in]	space = MSpace.Space


Return the rotate pivot translation in centimeters. This component is used internally by maya when the user moves the rotate pivot, or when the balance flag is set to true in the MfnTransform::setRotatePivot method. It serves as a compensation that allows existing transformations to be preserved. For the precise mathematics, refer to the transformation matrix details in the description section of  MFnTransform .'''
        pass

    def rotateBy(self, rotation, order, space): 
        '''rotateBy(self, rotation, order, space)
Arguments:
	[in]	rotation = double3
	[in]	order = MTransformationMatrix.RotationOrder
	[in]	space = MSpace.Space


Relatively change the rotation component of this transformation.'''
        pass

    def setRotation(self, rotation, order): 
        '''setRotation(self, rotation, order)
Arguments:
	[in]	rotation = double3
	[in]	order = MTransformationMatrix.RotationOrder


Change the rotation component of this transformation. The rotation is set in  MSpace::kTransform  space.'''
        pass

    def limitValue(self, type): 
        '''limitValue(self, type) -> double
Returns: Current value of the specified limit as internal unit.

Arguments:
	[in]	type = MFnTransform.LimitType


Determine the current value of the specified limit.'''
        pass

    def type(self): 
        '''type(self) -> MFn.Type

'''
        pass

    def transformation(self): 
        '''transformation(self) -> MTransformationMatrix
Returns: The transformation matrix represented by this transform.


Retrieve the transformation matrix represented by this transform.'''
        pass

    def setTranslation(self, vector, space): 
        '''setTranslation(self, vector, space)
Arguments:
	[in]	vector = MVector
	[in]	space = MSpace.Space


Change the translation component of this transformation.'''
        pass

    def enableLimit(self, type, flag): 
        '''enableLimit(self, type, flag)
Arguments:
	[in]	type = MFnTransform.LimitType
	[in]	flag = bool


Enable or disable the limit value for the specified limit type.'''
        pass

    def getRotationQuaternion(self, space, x, y, z, w): 
        '''getRotationQuaternion(self, space, x, y, z, w)
Arguments:
	[out]	x = double
	[out]	y = double
	[out]	z = double
	[out]	w = double
	[in]	space = MSpace.Space


Retrieve the rotation component of this transformation as a quaternion. The only valid transformation spaces for this method are  MSpace::kTransform  and  MSpace::kWorld . All other spaces are treated as being equivalent to  MSpace::kTransform .'''
        pass

    def rotationOrder(self): 
        '''rotationOrder(self) -> MTransformationMatrix.RotationOrder
Returns: rotation order


Returns the rotation order for the transform matrix - the order in which the Euler angles are applied to create the end rotation.'''
        pass

    def setRotatePivot(self, point, space, balance): 
        '''setRotatePivot(self, point, space, balance)
Arguments:
	[in]	point = MPoint
	[in]	space = MSpace.Space
	[in]	balance = bool


Set the rotate pivot in centimeters about which rotation is applied.'''
        pass

    def setRestPosition(self, matrix): 
        '''setRestPosition(self, matrix)
Arguments:
	[in]	matrix = MTransformationMatrix


Change the saved rest position of this transform. The rest position is not used internally by Maya. It is exclusively for use from the API as a temporary cache, which can be set and restored within a single Maya session. Note that the rest position is not saved with the scene.'''
        pass

    def scalePivotTranslation(self, space): 
        '''scalePivotTranslation(self, space) -> MVector
Returns: Scale pivot translation in centimeters

Arguments:
	[in]	space = MSpace.Space


Returns the scale pivot translation in centimeters. This component is used as a compensation by maya when the user moves the scale pivot, or when the balance flag is set to true in the MfnTransform::setScalePivot method. The scale pivot translation serves as a compensation that allows existing transformations to be preserved when the scale pivot is modified. For the precise mathematics, refer to the transformation matrix details in the description section of  MFnTransform .'''
        pass

    def setScale(self, scale): 
        '''setScale(self, scale)
Arguments:
	[in]	scale = double3


Set the scaling component of this transformation.'''
        pass

    def setLimit(self, type, value): 
        '''setLimit(self, type, value)
Arguments:
	[in]	type = MFnTransform.LimitType
	[in]	value = double


Change the limit value for the specified limit type, and automatically enable the limit to be true.'''
        pass

    def getScale(self, scale): 
        '''getScale(self, scale)
Arguments:
	[out]	scale = double3


Retrieve the scaling component of this transformation.'''
        pass

    def clearRestPosition(self): 
        '''clearRestPosition(self)

Clear the saved rest position of this transform.'''
        pass

    def resetFromRestPosition(self): 
        '''resetFromRestPosition(self)

Reset the transform to its rest position.'''
        pass

    def scaleBy(self, scale): 
        '''scaleBy(self, scale)
Arguments:
	[in]	scale = double3


Relatively scale this transformation.'''
        pass

    def className(self): 
        '''className(self) -> char*

'''
        pass

    def setShear(self, shear): 
        '''setShear(self, shear)
Arguments:
	[in]	shear = double3


Set the shearing component of this transformation.'''
        pass

    def isLimited(self, type): 
        '''isLimited(self, type) -> bool
Returns: True or false, true means the limit is enabled.

Arguments:
	[in]	type = MFnTransform.LimitType


Determine if the specified limit attribute is enabled or disabled.'''
        pass

    def setRotateOrientation(self, quat, space, balance): 
        '''setRotateOrientation(self, quat, space, balance)
Arguments:
	[in]	quat = MQuaternion
	[in]	space = MSpace.Space
	[in]	balance = bool


Set the rotation used to orient the local rotation space. For the precise mathematics, refer to the transformation matrix details in the description section of  MFnTransform .'''
        pass

    def setRotationOrder(self, order, reorder): 
        '''setRotationOrder(self, order, reorder)
Arguments:
	[in]	order = MTransformationMatrix.RotationOrder
	[in]	reorder = bool


Change the rotation order for the transform - the order in which the Euler angles are applied to create the end rotation.'''
        pass

    def setScalePivotTranslation(self, vector, space): 
        '''setScalePivotTranslation(self, vector, space)
Arguments:
	[in]	vector = MVector
	[in]	space = MSpace.Space


Set the scale pivot translation in centimeters. This component is used internally by maya when the user moves the scale pivot, or when the balance flag is set to true in the MfnTransform::setScalePivot method. It serves as a compensation that allows existing transformations to be preserved when the scale pivot is modified. For the precise mathematics, refer to the transformation matrix details in the description section of  MFnTransform .'''
        pass

    def setRotationQuaternion(self, x, y, z, w, space): 
        '''setRotationQuaternion(self, x, y, z, w, space)
Arguments:
	[in]	x = double
	[in]	y = double
	[in]	z = double
	[in]	w = double
	[in]	space = MSpace.Space


Change the rotation component of this transformation using a quaternion. The only valid transformation spaces for this method are  MSpace::kTransform  and  MSpace::kWorld . All other spaces are treated as being equivalent to  MSpace::kTransform .'''
        pass

class MFnTripleIndexedComponent:
    '''Triple indexed component function set. This function set allows you to create, edit, and query triple indexed components. Triple indexed components store 3 dimensional index values. '''
    def __init__(self):
        pass


    def getCompleteData(self, maxS, maxT, maxU): 
        '''getCompleteData(self, maxS, maxT, maxU)
Arguments:
	[out]	maxS = int
	[out]	maxT = int
	[out]	maxU = int


Returns the number of elements for the complete component. A complete component means that all elements are selected.'''
        pass

    def getElement(self, index, sIndex, tIndex, uIndex): 
        '''getElement(self, index, sIndex, tIndex, uIndex)
Arguments:
	[in]	index = int
	[out]	sIndex = int
	[out]	tIndex = int
	[out]	uIndex = int


Get the specified element from the component.'''
        pass

    def getElements(self, sIndices, tIndices, uIndices): 
        '''getElements(self, sIndices, tIndices, uIndices)
Arguments:
	[out]	sIndices = MIntArray
	[out]	tIndices = MIntArray
	[out]	uIndices = MIntArray


Get all of the element indices from the component.'''
        pass

    def create(self, compType): 
        '''create(self, compType) -> MObject
Returns: The new component

Arguments:
	[in]	compType = MFn.Type


Create a triple indexed component of the given type. Allowable types are'''
        pass

    def addElements(self, sIndices, tIndices, uIndices): 
        '''addElements(self, sIndices, tIndices, uIndices)
Arguments:
	[in]	sIndices = MIntArray
	[in]	tIndices = MIntArray
	[in]	uIndices = MIntArray


Add the specified elements to the component.'''
        pass

    def className(self): 
        '''className(self) -> char*

'''
        pass

    def setCompleteData(self, maxS, maxT, maxU): 
        '''setCompleteData(self, maxS, maxT, maxU)
Arguments:
	[in]	maxS = int
	[in]	maxT = int
	[in]	maxU = int


Marks the component as complete (meaning all items are selected) and uses the argument to identify the total number of elements selected. If the component should contain N element indices, then the range would be [0,N-1].'''
        pass

    def type(self): 
        '''type(self) -> MFn.Type

'''
        pass

    def addElement(self, sIndex, tIndex, uIndex): 
        '''addElement(self, sIndex, tIndex, uIndex)
Arguments:
	[in]	sIndex = int
	[in]	tIndex = int
	[in]	uIndex = int


Add the specified element to the component.'''
        pass

class MFnTypedAttribute:
    '''Typed attribute function set. MFnTypedAttribute is the function set for typed dependency node attributes. A typed attribute accepts exactly one type of data. The type that it accepts is set when the attribute is created.Once a typed attribute had been created, the data for it can be accessed using an MDataHandle while in your node's compute method. '''
    def __init__(self):
        pass


    def attrType(self): 
        '''attrType(self) -> MFnData.Type


Return the type of this attribute.'''
        pass

    def setDefault(self, defaultCustomData): 
        '''setDefault(self, defaultCustomData)
Arguments:
	[in]	defaultCustomData = MObject


Set the default data for this attribute. The data can be created using the appropriate data function set.'''
        pass

    def create(self, full, brief, type, defaultData): 
        '''create(self, full, brief, type, defaultData) -> MObject
Returns: Pointer to the new attribute object.

Arguments:
	[in]	full = MString
	[in]	brief = MString
	[in]	type = MFnData.Type
	[in]	defaultData = MObject


Create a new typed attribute with the given type.'''
        pass

    def className(self): 
        '''className(self) -> char*

'''
        pass

    def getDefault(self, defaultCustomData): 
        '''getDefault(self, defaultCustomData)
Arguments:
	[out]	defaultCustomData = MObject


Gets the default data for this attribute.'''
        pass

    def type(self): 
        '''type(self) -> MFn.Type

'''
        pass

class MFnUint64SingleIndexedComponent:
    '''Single MUint64 indexed component function set. This function set allows you to create, edit, and query single MUint64 indexed components. Single indexed components store 1 dimensional index values, where each value is an MUint64. '''
    def __init__(self):
        pass


    def getCompleteData(self, numElements): 
        '''getCompleteData(self, numElements)
Arguments:
	[out]	numElements = MUint64


Returns the number of elements for the complete component. A complete component means that all elements are selected.'''
        pass

    def getElements(self, elements): 
        '''getElements(self, elements)
Arguments:
	[out]	elements = MUint64Array


Get all of the element indices from the component.'''
        pass

    def create(self, compType): 
        '''create(self, compType) -> MObject
Returns: The new component

Arguments:
	[in]	compType = MFn.Type


Create a single indexed component of the given type. Allowable types are'''
        pass

    def element(self, index): 
        '''element(self, index) -> MUint64
Returns: The index of the specified component

Arguments:
	[in]	index = int


Returns the specified element from the component.'''
        pass

    def className(self): 
        '''className(self) -> char*

'''
        pass

    def setCompleteData(self, numElements): 
        '''setCompleteData(self, numElements)
Arguments:
	[in]	numElements = MUint64


Marks the component as complete (meaning all items are selected) and uses the argument to identify the total number of elements selected. If the component should contain N element indices, then the range would be [0,N-1].'''
        pass

    def type(self): 
        '''type(self) -> MFn.Type

'''
        pass

    def addElement(self, element): 
        '''addElement(self, element)
Arguments:
	[in]	element = MUint64


Add the specified element to the component.'''
        pass

    def addElements(self, elements): 
        '''addElements(self, elements)
Arguments:
	[in]	elements = MUint64Array


Add the specified elements to the component.'''
        pass

class MFnUnitAttribute:
    '''Unit attribute Function set. MFnUnitAttribute is the function set for dependency nodes attributes that store one of the fundamental types of Maya data. The currently supported types are MAngle, MDistance, and MTime.It is possible to set the defaults using a double. This is valid for angles and distances. In the case of angles, the value is assumed to be in radians, and in the case of distances, it is assumed to be in centimeters. Time values should not be set using a double.It is possible to use unit attributes in place of double attributes when creating numeric compounds (see MFnNumericAttrbute). To create a numeric compound of three distance values, create the three child attributes using MFnUnitAttribute and then pass the children into the create method of MFnNumericAttribute. '''
    def __init__(self):
        pass


    def hasSoftMax(self): 
        '''hasSoftMax(self) -> bool


Determine whether or not this attribute has a soft maximum value set.'''
        pass

    def setMin(self, minValue): 
        '''setMin(self, minValue)
Arguments:
	[in]	minValue = MDistance


Set the minimum value for this attribute.'''
        pass

    def setSoftMin(self, minValue): 
        '''setSoftMin(self, minValue)
Arguments:
	[in]	minValue = MDistance


Set the soft minimum value for this attribute.'''
        pass

    def getDefault(self, defaultValue): 
        '''getDefault(self, defaultValue)
Arguments:
	[out]	defaultValue = MDistance


Gets the default value for this attribute.'''
        pass

    def kLast(self):
        '''This is an enum of Type.
Description: Last value, for counting.
Value: 4'''
        pass

    def kAngle(self):
        '''This is an enum of Type.
Description: Angular attribute.
Value: 1'''
        pass

    def kDistance(self):
        '''This is an enum of Type.
Description: Distance (linear) attribute.
Value: 2'''
        pass

    def kInvalid(self):
        '''This is an enum of Type.
Description: Invalid unit type.
Value: 0'''
        pass

    def kTime(self):
        '''This is an enum of Type.
Description: Time attribute.
Value: 3'''
        pass

    class Type:
        '''Non-functional class.  Values for this enum:
        kLast
        kAngle
        kDistance
        kInvalid
        kTime
'''
        def __init__(self):
            pass

    def create(self, full, brief, defaultValue): 
        '''create(self, full, brief, defaultValue) -> MObject

Arguments:
	[in]	full = MString
	[in]	brief = MString
	[in]	defaultValue = MDistance


Create a new unit attribute of type  distance  and return it as an  MObject .'''
        pass

    def setMax(self, maxValue): 
        '''setMax(self, maxValue)
Arguments:
	[in]	maxValue = MDistance


Set the maximum value for this attribute.'''
        pass

    def hasSoftMin(self): 
        '''hasSoftMin(self) -> bool


Determine whether or not this attribute has a soft minimum value set.'''
        pass

    def className(self): 
        '''className(self) -> char*

'''
        pass

    def setSoftMax(self, maxValue): 
        '''setSoftMax(self, maxValue)
Arguments:
	[in]	maxValue = MDistance


Set the soft maximum value for this attribute.'''
        pass

    def unitType(self): 
        '''unitType(self) -> MFnUnitAttribute.Type


Return the unit type of this attribute.'''
        pass

    def hasMax(self): 
        '''hasMax(self) -> bool


Determine whether or not this attribute has a maximum value set.'''
        pass

    def getMin(self, minValue): 
        '''getMin(self, minValue)
Arguments:
	[out]	minValue = MDistance


Return the minimum value for this attribute.'''
        pass

    def getMax(self, maxValue): 
        '''getMax(self, maxValue)
Arguments:
	[out]	maxValue = MDistance


Return the maximum value for this attribute.'''
        pass

    def getSoftMax(self, maxValue): 
        '''getSoftMax(self, maxValue)
Arguments:
	[out]	maxValue = MDistance


Return the soft maximum value for this attribute.'''
        pass

    def hasMin(self): 
        '''hasMin(self) -> bool


Determine whether or not this attribute has a minimum value set.'''
        pass

    def type(self): 
        '''type(self) -> MFn.Type

'''
        pass

    def getSoftMin(self, minValue): 
        '''getSoftMin(self, minValue)
Arguments:
	[out]	minValue = MDistance


Return the soft minimum value for this attribute.'''
        pass

    def setDefault(self, defaultValue): 
        '''setDefault(self, defaultValue)
Arguments:
	[in]	defaultValue = MDistance


Set a new default value for this attribute.'''
        pass

class MFnUInt64ArrayData:
    '''MUint64 array function set for dependency node data. MFnUInt64ArrayData allows the creation and manipulation of MUint64Array data objects for use in the dependency graph.If a user written dependency node either accepts or produces MUint64Arrays, then this class is used to extract or create the data that comes from or goes to other dependency graph nodes. The MDataHandle::type method will return kUInt64Array when data of this type is present. To access it, the MDataHandle::data method is used to get an MObject for the data and this should then be used to initialize an instance of MFnUInt64ArrayData. '''
    def __init__(self):
        pass


    def set(self, array): 
        '''set(self, array)
Arguments:
	[in]	array = MUint64Array


Set the instance to contain the MUint64s defined in the given  MUint64Array .'''
        pass

    def __getitem__(self, index): 
        '''__getitem__(self, index) -> MFnUInt64ArrayData.MUint64&
Returns: The indicated MUint64 

Arguments:
	[in]	index = int


Extract the indicated MUint64 from the instance. by the function set. The MUint64 returned by this method is editable, so any changes to the return instance also affects the  MObject  operated upon by this function set.'''
        pass

    def create(self, arr): 
        '''create(self, arr) -> MObject
Returns: The newly created MObject 

Arguments:
	[in]	arr = MUint64Array


Create a new  MObject , attach it to this instance, and initialize it to contain the data from the given  MUint64Array .'''
        pass

    def copyTo(self, dest): 
        '''copyTo(self, dest)
Arguments:
	[out]	dest = MUint64Array


Copy all the MUint64s in the instance into the given  MUint64Array .'''
        pass

    def className(self): 
        '''className(self) -> char*

'''
        pass

    def length(self): 
        '''length(self) -> int
Returns: The number of MUint64s in the instance 


Return the number of MUint64s in the instance.'''
        pass

    def array(self): 
        '''array(self) -> MUint64Array
Returns: A copy of the MUint64Array held in this instance 


Return an  MUint64Array  containing the MUint64 array currently operated upon by the function set. The  MUint64Array  returned by this method is editable, so any changes to the return instance also affects the  MObject  operated upon by this function set.'''
        pass

    def type(self): 
        '''type(self) -> MFn.Type

'''
        pass

class MFnVectorArrayData:
    '''int array function set for dependency node data. MFnVectorArrayData allows the creation and manipulation of MVectorArray data objects for use in the dependency graph.If a user written dependency node either accepts or produces MVectorArrays, then this class is used to extract or create the data that comes from or goes to other dependency graph nodes. The MDataHandle::type method will return kVectorArray when data of this type is present. To access it, the MDataHandle::data method is used to get an MObject for the data and this should then be used to initialize an instance of MFnVectorArrayData. '''
    def __init__(self):
        pass


    def set(self, array): 
        '''set(self, array)
Arguments:
	[in]	array = MVectorArray


Set the instance to contain the vectors defined in the given  MVectorArray .'''
        pass

    def create(self, arr): 
        '''create(self, arr) -> MObject
Returns: The newly created MObject 

Arguments:
	[in]	arr = MVectorArray


Create a new  MObject , attach it to this instance, and initialize it to contain the data from the given  MVectorArray .'''
        pass

    def copyTo(self, dest): 
        '''copyTo(self, dest)
Arguments:
	[out]	dest = MVectorArray


Copy all the vectors in the instance into the given  MVectorArray .'''
        pass

    def className(self): 
        '''className(self) -> char*

'''
        pass

    def length(self): 
        '''length(self) -> int
Returns: The number of vectors in the instance 


Return the number of vectors in the instance.'''
        pass

    def array(self): 
        '''array(self) -> MVectorArray
Returns: A copy of the MVectorArray held in this instance 


Return an  MVectorArray  containing the vector array currently operated upon by the function set. The  MVectorArray  returned by this method is editable, so any changes to the return instance also affects the  MObject  operated upon by this function set.'''
        pass

    def type(self): 
        '''type(self) -> MFn.Type

'''
        pass

class MFnVolumeLight:
    '''Manage volume Light dependency Nodes. MFnVolumeLight facilitates creation and manipulation of dependency graph nodes representing voume lights. '''
    def __init__(self):
        pass


    def setEmitAmbient(self, emit_ambient): 
        '''setEmitAmbient(self, emit_ambient)
Arguments:
	[in]	emit_ambient = bool


Sets the value of the "emitAmbient" attribute of a volume light node.'''
        pass

    def setConeEndRadius(self, cone_end_radius): 
        '''setConeEndRadius(self, cone_end_radius)
Arguments:
	[in]	cone_end_radius = float


Sets the value of the "coneEndRadius" attribute of a volume light node.'''
        pass

    def emitAmbient(self): 
        '''emitAmbient(self) -> bool
Returns: The value of the "emitAmbient" attribute of the volume light node.


Retrieves the value of the "emitAmbient" attribute.'''
        pass

    def colorRamp(self): 
        '''colorRamp(self) -> MRampAttribute
Returns: The color ramp attribute


Retrieves the "colorRamp" attribute.'''
        pass

    def lightShape(self): 
        '''lightShape(self) -> MFnVolumeLight.MLightShape
Returns: The value of the "lightShape" attribute of the volume light node.


Retrieves the "lightShape" attribute of the light. The shape can be one of the following.'''
        pass

    def create(self, parent, UIvisible, wantTransform): 
        '''create(self, parent, UIvisible, wantTransform) -> MObject
Returns: MObject representing the new dependency node.

Arguments:
	[in]	parent = MObject
	[in]	UIvisible = bool
	[in]	wantTransform = bool


Creates a new volume light dependency graph node and adds it to the dependency graph. If the UIvisible parameter is true, the new node will be connected to the light classification node (which allows the UI to recognize the node as a light) and added to the default light list. If UIvisible is false, the node will be created in isolation.'''
        pass

    def volumeLightDirection(self): 
        '''volumeLightDirection(self) -> MFnVolumeLight.MLightDirection
Returns: The value of the "lightDirection" attribute of the volume light node.


Retrieves the value of the "volumeLightDirection" attribute.'''
        pass

    def kCylinderVolume(self):
        '''This is an enum of MLightShape.
Description: 
Value: 2'''
        pass

    def kBoxVolume(self):
        '''This is an enum of MLightShape.
Description: 
Value: 0'''
        pass

    def kConeVolume(self):
        '''This is an enum of MLightShape.
Description: 
Value: 3'''
        pass

    def kSphereVolume(self):
        '''This is an enum of MLightShape.
Description: 
Value: 1'''
        pass

    class MLightShape:
        '''Non-functional class.  Values for this enum:
        kCylinderVolume
        kBoxVolume
        kConeVolume
        kSphereVolume
'''
        def __init__(self):
            pass

    def setLightShape(self, light_shape): 
        '''setLightShape(self, light_shape)
Arguments:
	[in]	light_shape = MFnVolumeLight.MLightShape


Sets the value of the "lightShape" attribute of a volume light node. The shape can be one of the following:'''
        pass

    def kDownAxis(self):
        '''This is an enum of MLightDirection.
Description: Light travels down the axis, like a directional light pointing in the negative Y direction.
Value: 2'''
        pass

    def kOutward(self):
        '''This is an enum of MLightDirection.
Description: Light travels outwared from the center of a box- or sphere-shaped volume, and outward from the axis of a cylinder- or cone-shaped volume.
Value: 0'''
        pass

    def kInward(self):
        '''This is an enum of MLightDirection.
Description: Light travels inward toward the center of a box- or sphere-shaped volume, and inward toward the axis of a cylinder- or cone-shaped volume.
Value: 1'''
        pass

    class MLightDirection:
        '''Non-functional class.  Values for this enum:
        kDownAxis
        kOutward
        kInward
'''
        def __init__(self):
            pass

    def className(self): 
        '''className(self) -> char*

'''
        pass

    def arc(self): 
        '''arc(self) -> float
Returns: The value of the "arc" attribute of the volume light node.


Retrieves the value of the "arc" attribute. The arc is an angular slice of the light about the y axis. The value can range from 0 to 360 degrees.'''
        pass

    def setVolumeLightDirection(self, volume_light_direction): 
        '''setVolumeLightDirection(self, volume_light_direction)
Arguments:
	[in]	volume_light_direction = MFnVolumeLight.MLightDirection


Sets the value of the "volumeLightDirection" attribute of a volume light node. The shape can be one of the following.'''
        pass

    def setArc(self, arc): 
        '''setArc(self, arc)
Arguments:
	[in]	arc = float


Sets the value of the "arc" attribute of a volume light node.'''
        pass

    def penumbraRamp(self): 
        '''penumbraRamp(self) -> MRampAttribute
Returns: The penumbra ramp attribute


Retrieves the "penumbraRamp" attribute.'''
        pass

    def type(self): 
        '''type(self) -> MFn.Type

'''
        pass

    def coneEndRadius(self): 
        '''coneEndRadius(self) -> float
Returns: The value of the "coneEndRadius" attribute of the volume light node.


Retrieves the value of the "coneEndRadius" attribute. The coneEndRadius attribute determines the relative size of the one end of the cone. At a value of 1.0 it is a cylinder, while at 0 it is a cone.'''
        pass

class MGlobal:
    '''Static class providing common API global functions. Provide methods for selection, 3D-views, time, model manipulation and MEL commands.MGlobal is a static class which provides access to Maya's model (3d graphical database).MGlobal provides methods for selection, 3d-views, setting the global time, adding to the DAG, and executing MEL commands from within the API. There are multiple methods provided in this class for executing MEL within the API. Plug-ins requiring the execution of MEL from the non-main Maya thread must use the executeCommandOnIdle() method to avoid program errors.MGlobal also provides methods for controlling error logging in the API. '''
    def __init__(self):
        pass


    def unselectByName(self, name): 
        '''unselectByName(self, name)
Arguments:
	[in]	name = MString


Removes objects matching the pattern from the active selection list.'''
        pass

    def upAxis(self): 
        '''upAxis(self) -> MVector


This method returns the model's current up axis.'''
        pass

    def isZAxisUp(self): 
        '''isZAxisUp(self) -> bool


This method returns true if, currently, the Z-axis is UP.'''
        pass

    def addToModelAt(self, object, point, scale, rotation, rotOrder): 
        '''addToModelAt(self, object, point, scale, rotation, rotOrder)
Arguments:
	[in]	object = MObject
	[in]	point = MVector
	[in]	scale = double3
	[in]	rotation = double3
	[in]	rotOrder = MTransformationMatrix.RotationOrder


Adds the specified dag object to the DAG and transform the object by the specified arguments. This method is only valid for dag nodes. If the specified object is not of type  MFn::kDagNode  then  MS::kInvalidParameter  will be returned.'''
        pass

    def kRemoveFromList(self):
        '''This is an enum of ListAdjustment.
Description: Remove the items from the list.
Value: 3'''
        pass

    def kReplaceList(self):
        '''This is an enum of ListAdjustment.
Description: Totally replace the list with the given items.
Value: 0'''
        pass

    def kXORWithList(self):
        '''This is an enum of ListAdjustment.
Description: For each item, remove it to the list if that are already present, add it otherwise.
Value: 1'''
        pass

    def kAddToHeadOfList(self):
        '''This is an enum of ListAdjustment.
Description: Add to beginning of the list.
Value: 4'''
        pass

    def kAddToList(self):
        '''This is an enum of ListAdjustment.
Description: Add the items to the list.
Value: 2'''
        pass

    class ListAdjustment:
        '''Non-functional class.  Values for this enum:
        kRemoveFromList
        kReplaceList
        kXORWithList
        kAddToHeadOfList
        kAddToList
'''
        def __init__(self):
            pass

    def setHiliteList(self, list): 
        '''setHiliteList(self, list)
Arguments:
	[in]	list = MSelectionList


Sets the current hilite list. The current selection list is unchanged.'''
        pass

    def getRichSelection(self, defaultToActiveSelection, richSelection): 
        '''getRichSelection(self, defaultToActiveSelection, richSelection)
Arguments:
	[out]	richSelection = MRichSelection
	[in]	defaultToActiveSelection = bool


Returns the current rich selection (usually the active selection with any soft selection and symmetry applied). Optionally if no rich selection exists, the current active selection can be returned instead (reducing the need for duplicated code).'''
        pass

    def getAssociatedSets(self, list, setArray): 
        '''getAssociatedSets(self, list, setArray)
Arguments:
	[in]	list = MSelectionList
	[out]	setArray = MObjectArray


This utility method finds all the sets that the items in the given selection list are members of.'''
        pass

    def stopErrorLogging(self): 
        '''stopErrorLogging(self)

This method disables output to the API error log but does not close the log file.'''
        pass

    def selectionMethod(self): 
        '''selectionMethod(self) -> MGlobal.SelectionMethod


Determines the selection method that should be used in the currently active viewport. This is useful as input to the "selectFromScreen" functions.'''
        pass

    def optionVarStringValue(self, name, result): 
        '''optionVarStringValue(self, name, result) -> MString

Arguments:
	[in]	name = MString
	[in]	result = bool


This method is used to get the option variable value of type string'''
        pass

    def kInteractive(self):
        '''This is an enum of MMayaState.
Description: Running with a UI.
Value: 0'''
        pass

    def kBatch(self):
        '''This is an enum of MMayaState.
Description: Running without a UI.
Value: 1'''
        pass

    def kBaseUIMode(self):
        '''This is an enum of MMayaState.
Description: Running in baseUI mode.
Value: 3'''
        pass

    def kLibraryApp(self):
        '''This is an enum of MMayaState.
Description: A standalone (
Value: 2'''
        pass

    class MMayaState:
        '''Non-functional class.  Values for this enum:
        kInteractive
        kBatch
        kBaseUIMode
        kLibraryApp
'''
        def __init__(self):
            pass

    def deleteNode(self, object): 
        '''deleteNode(self, object)
Arguments:
	[in]	object = MObject


Delete the given dag node or dependency graph node.'''
        pass

    def apiVersion(self): 
        '''apiVersion(self) -> int


Returns a number describing the version of the Maya API at runtime.'''
        pass

    def isYAxisUp(self): 
        '''isYAxisUp(self) -> bool


This method returns true if, currently, the Y-axis is UP.'''
        pass

    def errorLoggingIsOn(self): 
        '''errorLoggingIsOn(self) -> bool
Returns: Boolean value: true Errors are being logged false otherwise.


This method determines whether or not API errors are being logged.'''
        pass

    def selectionMode(self): 
        '''selectionMode(self) -> MGlobal.MSelectionMode


Determines Maya's selection mode.'''
        pass

    def select(self, object, component, listAdjustment): 
        '''select(self, object, component, listAdjustment)
Arguments:
	[in]	object = MDagPath
	[in]	component = MObject
	[in]	listAdjustment = MGlobal.ListAdjustment


Put the given object or components on the active selection list. If the component is null then the object in the dag path will be selected, otherwise the given component will be selected.'''
        pass

    def resetToDefaultErrorLogPathName(self): 
        '''resetToDefaultErrorLogPathName(self)

Closes the current log file if it is open, and then resets the log path to the default path. Logging is disabled and the log file speicified by the default path is not opened. If logging is disabled, it remains disabled. Use  startErrorLogging()  to enable logging to the default log file. If the current path is the default path, no action is taken, but an invalid parameter error is returned.'''
        pass

    def errorLogPathName(self): 
        '''errorLogPathName(self) -> MString
Returns: Error log path name


Determines the path name of the current error log file. Returns the null string on failure.'''
        pass

    def setYAxisUp(self, rotateView): 
        '''setYAxisUp(self, rotateView)
Arguments:
	[in]	rotateView = bool


This method sets the flag to identify which axis is Up, and rotates the ground plane around around the X-axis 90 degrees to get the Y-Up from Z-Up.'''
        pass

    def setMiscSelectionMask(self, mask): 
        '''setMiscSelectionMask(self, mask)
Arguments:
	[in]	mask = MSelectionMask


Set the miscellaneous selection mask to the supplied value'''
        pass

    def setZAxisUp(self, rotateView): 
        '''setZAxisUp(self, rotateView)
Arguments:
	[in]	rotateView = bool


This method sets the flag to identify which axis is Up, and rotates the ground plane around around the X-axis -90 degrees to get the Z-Up from Y-Up.'''
        pass

    def kSelectComponentMode(self):
        '''This is an enum of MSelectionMode.
Description: Select components.
Value: 1'''
        pass

    def kSelectTemplateMode(self):
        '''This is an enum of MSelectionMode.
Description: Select templates.
Value: 4'''
        pass

    def kSelectRootMode(self):
        '''This is an enum of MSelectionMode.
Description: Select DAG roots.
Value: 2'''
        pass

    def kSelectObjectMode(self):
        '''This is an enum of MSelectionMode.
Description: Select objects.
Value: 0'''
        pass

    def kSelectLeafMode(self):
        '''This is an enum of MSelectionMode.
Description: Select DAG leaves.
Value: 3'''
        pass

    class MSelectionMode:
        '''Non-functional class.  Values for this enum:
        kSelectComponentMode
        kSelectTemplateMode
        kSelectRootMode
        kSelectObjectMode
        kSelectLeafMode
'''
        def __init__(self):
            pass

    def setObjectSelectionMask(self, mask): 
        '''setObjectSelectionMask(self, mask)
Arguments:
	[in]	mask = MSelectionMask


Set the object selection mask to the supplied value'''
        pass

    def kWireframeSelectMethod(self):
        '''This is an enum of SelectionMethod.
Description: Select based on the surface of the objects.
Value: 1'''
        pass

    def kSurfaceSelectMethod(self):
        '''This is an enum of SelectionMethod.
Description: Select based on the wireframe of the objects.
Value: 0'''
        pass

    class SelectionMethod:
        '''Non-functional class.  Values for this enum:
        kWireframeSelectMethod
        kSurfaceSelectMethod
'''
        def __init__(self):
            pass

    def viewFrame(self, time): 
        '''viewFrame(self, time)
Arguments:
	[in]	time = double


Sets the global time to the specified time. This function is optimized for sequential time values that are monotonically increasing. While one can set the time randomly with this function, a significant performance hit will be incurred.'''
        pass

    def isSelected(self, object): 
        '''isSelected(self, object) -> bool

Arguments:
	[in]	object = MObject


Determines whether the given object is on the active selection list.'''
        pass

    def addToModel(self, object, parent): 
        '''addToModel(self, object, parent)
Arguments:
	[in]	object = MObject
	[in]	parent = MObject


This method is used to add new dag objects to the model. If no parent node is specified, then the node is added under the world. When a node is added under the world, then a transform node is automatically created as a parent. This assumes that the node being added is not already a transform node. This method is only valid for dag nodes. If the specified object is not of type  MFn::kDagNode  then  MS::kInvalidParameter  will be returned.'''
        pass

    def closeErrorLog(self): 
        '''closeErrorLog(self)

This method closes the API error log file. If error logging is currently enabled this method disables it. The error log is time and date stamped before it is closed. After the log is closed the error log path name is reset to the default path name. If the error log file is already closed, then no action is taken.'''
        pass

    def selectCommand(self, src, listAdjustment): 
        '''selectCommand(self, src, listAdjustment)
Arguments:
	[in]	src = MSelectionList
	[in]	listAdjustment = MGlobal.ListAdjustment


Set the active selection list, by calling the built in Maya select command. This differs from setActiveSelectionList in that in this version Maya takes over the selection list you give it and will be responsible for maintaing the necessary information required for undo, redo, and journalling.'''
        pass

    def startErrorLogging(self, logPathName): 
        '''startErrorLogging(self, logPathName)
Arguments:
	[in]	logPathName = MString


MapiSuccess( &ReturnStatus );. 
'''
        pass

    def displayError(self, theError): 
        '''displayError(self, theError)
Arguments:
	[in]	theError = MString


This method is used to display an error in the script editor.'''
        pass

    def getSelectionListByName(self, name, list): 
        '''getSelectionListByName(self, name, list)
Arguments:
	[in]	name = MString
	[out]	list = MSelectionList


This method fills a selection list with all of the objects that match a specified name. The name may use the same type of regular expressions the can be used in MEL commands. For example, the pattern "pCube*" will match all occurances of objects that begin their names with "pCube".'''
        pass

    def getLiveList(self, dest): 
        '''getLiveList(self, dest)
Arguments:
	[out]	dest = MSelectionList


Returns a copy of the live list. When a user performs a "Modify->Make Live" in the user interface the currently selected objects are added to the live list.'''
        pass

    def selectByName(self, name, listAdjustment): 
        '''selectByName(self, name, listAdjustment)
Arguments:
	[in]	name = MString
	[in]	listAdjustment = MGlobal.ListAdjustment


Puts objects that match the give name on the active selection list.'''
        pass

    def isRedoing(self): 
        '''isRedoing(self) -> bool


Returns true if Maya is currently in the middle of an redo.'''
        pass

    def setOptionVarValue(self, name, value): 
        '''setOptionVarValue(self, name, value) -> bool
Returns: true 

Arguments:
	[in]	name = MString
	[in]	value = MString


This method is used to set the option variable value of type string'''
        pass

    def miscSelectionMask(self): 
        '''miscSelectionMask(self) -> MSelectionMask


Returns the miscellaneous selection mask.'''
        pass

    def selectFromScreen(self, start_x, start_y, end_x, end_y, listAdjustment, selectMethod): 
        '''selectFromScreen(self, start_x, start_y, end_x, end_y, listAdjustment, selectMethod)
Arguments:
	[in]	start_x = short
	[in]	start_y = short
	[in]	end_x = short
	[in]	end_y = short
	[in]	listAdjustment = MGlobal.ListAdjustment
	[in]	selectMethod = MGlobal.SelectionMethod


Perform marquee type selection on the dag. If an object intersects the selection rectangle, it is selected according to listAdjustment.'''
        pass

    def optionVarDoubleValue(self, name, result): 
        '''optionVarDoubleValue(self, name, result) -> double

Arguments:
	[in]	name = MString
	[in]	result = bool


This method is used to get the option variable value of type double'''
        pass

    def doErrorLogEntry(self, errorLogEntry): 
        '''doErrorLogEntry(self, errorLogEntry)
Arguments:
	[in]	errorLogEntry = MString


Logs an entry in the currently open log file. It is not necessary for error logging to be enabled, but a log file must be open. A newline is appended to each log entry.'''
        pass

    def executeCommand(self, command, displayEnabled, undoEnabled, result): 
        '''executeCommand(self, command, displayEnabled, undoEnabled, result)
Arguments:
	[in]	command = MString
	[out]	result = MString
	[in]	displayEnabled = bool
	[in]	undoEnabled = bool


 This method is not available in Python. 
'''
        pass

    def objectSelectionMask(self): 
        '''objectSelectionMask(self) -> MSelectionMask


Returns the object selection mask.'''
        pass

    def setErrorLogPathName(self, logPathName): 
        '''setErrorLogPathName(self, logPathName)
Arguments:
	[in]	logPathName = MString


Closes the current log file if it is open, and then sets the log path to the given path. If logging is enabled, it remains enabled, but on the log file speicified by the new path. If logging is disabled, it remains disabled. Use  startErrorLogging()  to enable logging to the new file. If the given path name is the same as the current path name, no action is taken, but an invalid parameter error is returned.'''
        pass

    def executeCommandStringResult(self, command, displayEnabled, undoEnabled): 
        '''executeCommandStringResult(self, command, displayEnabled, undoEnabled) -> MString
Returns: String value returned by command

Arguments:
	[in]	command = MString
	[in]	displayEnabled = bool
	[in]	undoEnabled = bool


Executes a MEL command that returns a string result from the command engine. Optionally allows display of the command in the Command Window to be enabled or disabled. Defaults to disabled. Optionally allows undo for the command to be enabled or disabled. Defaults to disabled.'''
        pass

    def getActiveSelectionList(self, dest): 
        '''getActiveSelectionList(self, dest)
Arguments:
	[out]	dest = MSelectionList


Returns a copy of the active selection list.'''
        pass

    def setAnimSelectionMask(self, mask): 
        '''setAnimSelectionMask(self, mask)
Arguments:
	[in]	mask = MSelectionMask


Set the animation selection mask to the supplied value'''
        pass

    def optionVarIntValue(self, name, result): 
        '''optionVarIntValue(self, name, result) -> int

Arguments:
	[in]	name = MString
	[in]	result = bool


setting & getting option variable values 
'''
        pass

    def setActiveSelectionList(self, src, listAdjustment): 
        '''setActiveSelectionList(self, src, listAdjustment)
Arguments:
	[in]	src = MSelectionList
	[in]	listAdjustment = MGlobal.ListAdjustment


Set the active selection list. The selection items on the given list will update the contents of the active selection list as indicated by the listAdjustment parameter.'''
        pass

    def setComponentSelectionMask(self, mask): 
        '''setComponentSelectionMask(self, mask)
Arguments:
	[in]	mask = MSelectionMask


Set the component selection mask to the supplied value'''
        pass

    def mayaState(self): 
        '''mayaState(self) -> MGlobal.MMayaState


Returns an enumerated type specifying the way in which Maya was invoked.'''
        pass

    def mayaVersion(self): 
        '''mayaVersion(self) -> MString


Returns a string describing this version of Maya.'''
        pass

    def defaultErrorLogPathName(self): 
        '''defaultErrorLogPathName(self) -> MString


Determines the default path name of the error log file. Returns the null string on failure.'''
        pass

    def clearSelectionList(self): 
        '''clearSelectionList(self)

Removes all items from the active selection list.'''
        pass

    def executeCommandOnIdle(self, command, displayEnabled): 
        '''executeCommandOnIdle(self, command, displayEnabled)
Arguments:
	[in]	command = MString
	[in]	displayEnabled = bool


Sets a MEL command to execute on the next idle event. This is a thread safe way to execute commands, however, there is no access to the command results. Optionally allows display of the command in the Command Window to be enabled or disabled. Defaults to disabled.'''
        pass

    def setSelectionMode(self, mode): 
        '''setSelectionMode(self, mode)
Arguments:
	[in]	mode = MGlobal.MSelectionMode


Sets the selection mode.'''
        pass

    def removeFromModel(self, object): 
        '''removeFromModel(self, object)
Arguments:
	[in]	object = MObject


Removes the specified dag node from the scene. This method is only valid for dag nodes. If the specified object is not of type  MFn::kDagNode  then  MS::kInvalidParameter  will be returned.'''
        pass

    def unselect(self, object, component): 
        '''unselect(self, object, component)
Arguments:
	[in]	object = MDagPath
	[in]	component = MObject


Remove the given object/components from the active selection list. If components is null then the object will be unselected, otherwise the components will be unselected.'''
        pass

    def sourceFile(self, fileName): 
        '''sourceFile(self, fileName)
Arguments:
	[in]	fileName = MString


Causes the MEL command engine to open the named file and execute the contents of the file as a MEL script. If the provided fileName is a Unix absolute pathname, then that file is opened. If a relative pathname is provided, the directories indicated by the environment variable, MAYA_SCRIPT_PATH, will be searched for a matching filename.'''
        pass

    def getHiliteList(self, dest): 
        '''getHiliteList(self, dest)
Arguments:
	[out]	dest = MSelectionList


Returns a copy of the hilite list. The hilite list contains all DAG objects that are hilited for component selection mode. (e.g. when the user right clicks over a Mesh object and chooses the "vertex" option the Mesh line drawing changes color and the mesh is added to the hiliteList.)'''
        pass

    def setDisplayCVs(self, src, state): 
        '''setDisplayCVs(self, src, state)
Arguments:
	[in]	src = MSelectionList
	[in]	state = bool


Controls drawing of control points in the specified selection list.'''
        pass

    def getFunctionSetList(self, forObject, array): 
        '''getFunctionSetList(self, forObject, array)
Arguments:
	[in]	forObject = MObject
	[out]	array = MStringArray


Gets a list of strings that represent the type of each function set that will accept this object. The strings match the values in MFn.h.'''
        pass

    def disableStow(self): 
        '''disableStow(self) -> bool


This method is used to query if the disabling of Stowing (hiding) and Unstowing (showing) windows is active..'''
        pass

    def displayWarning(self, theWarning): 
        '''displayWarning(self, theWarning)
Arguments:
	[in]	theWarning = MString


This method is used to display a warning in the script editor.'''
        pass

    def animSelectionMask(self): 
        '''animSelectionMask(self) -> MSelectionMask


Returns the animation selection mask.'''
        pass

    def componentSelectionMask(self): 
        '''componentSelectionMask(self) -> MSelectionMask


Returns the component selection mask.'''
        pass

    def displayInfo(self, theMessage): 
        '''displayInfo(self, theMessage)
Arguments:
	[in]	theMessage = MString


This method is used to display an informational message in the script editor.'''
        pass

    def isUndoing(self): 
        '''isUndoing(self) -> bool


Returns true if Maya is currently in the middle of an undo.'''
        pass

    def setDisableStow(self, state): 
        '''setDisableStow(self, state)
Arguments:
	[in]	state = bool


This method is used to make the visiblity of all Maya windows unchangable. If set to true, it disables any attempts to change the visiblity of any window. In addition, all popup windows will be supressed.'''
        pass

class MIffFile:
    '''Read file images stored on disk. This class provides a simple C++ interface to the IFF i/o library (flib). A class called MIffTag is used to create the 4 byte tags that are used to distinguish the different block types within an IFF file. '''
    def __init__(self):
        pass


    def getChunk(self, chunkTag, byteCount): 
        '''getChunk(self, chunkTag, byteCount) -> void*

Arguments:
	[in]	chunkTag = MIffTag
	[in]	byteCount = *


Opens a chunk for reading. A chunk is a block of unstructured data with an associated tag.'''
        pass

    def iffGetShort(self, result): 
        '''iffGetShort(self, result)
Arguments:
	[in]	result = short


Grabs a short from the active file.'''
        pass

    def beginGet(self, chunkTag, byteCount): 
        '''beginGet(self, chunkTag, byteCount)
Arguments:
	[in]	chunkTag = MIffTag
	[in]	byteCount = *


Begin grabbing the data.'''
        pass

    def get(self, buf, byteCount): 
        '''get(self, buf, byteCount) -> int

Arguments:
	[in]	buf = void
	[in]	byteCount = unsigned


Attempt to read 'byteCount' bytes from the file into the buffer pointed to by buf.'''
        pass

    def iffGetFloat(self, result): 
        '''iffGetFloat(self, result)
Arguments:
	[in]	result = float


Grabs a float from the active file.'''
        pass

    def endGet(self): 
        '''endGet(self)

Finish grabbing the data.'''
        pass

    def endReadGroup(self): 
        '''endReadGroup(self)

Closes group currently being read, skipping remaining data (including nested groups).'''
        pass

    def close(self): 
        '''close(self)

Close the currently open file.'''
        pass

    def beginReadGroup(self, id, type): 
        '''beginReadGroup(self, id, type)
Arguments:
	[in]	id = MIffTag
	[in]	type = MIffTag


Opens a group for reading. A group is composed of several chunks (sub-groups). Provides the id and type of the current group. Can be followed by several calls to chunk reading functions or to nested beginReadGroup(...) calls if needed (depending on the file structure). The function endReadGroup(...) is used to closed a group skipping remaining data (including nested groups).'''
        pass

    def open(self, fileName): 
        '''open(self, fileName)
Arguments:
	[in]	fileName = MString


Opens the file for reading.'''
        pass

    def isActive(self): 
        '''isActive(self) -> bool


Is the file currently active?'''
        pass

    def iffGetInt(self, result): 
        '''iffGetInt(self, result)
Arguments:
	[in]	result = int


Grabs an integer from the active file.'''
        pass

class MIffTag:
    '''Encapsulates IFF's 4 character block structure. Class MIffTag is used to create the 4 byte tags that are used to distinguish the different block types within an IFF file. '''
    def __init__(self):
        pass


    kCAT = ''
    '''Defines an unsorted group of FORM, e.g. images or sounds. '''

    kFOR8 = ''
    '''Eight byte aligned FORM block. '''

    kPROP = ''
    '''Four byte aligned FORM block. '''

    kCAT4 = ''
    '''Four byte aligned CAT block. '''

    kPRO4 = ''
    '''Four byte aligned PROP block. '''

    kLIS8 = ''
    '''Eight byte aligned LIST block. '''

    kPRO8 = ''
    '''Eight byte aligned PROP block. '''

    kLIST = ''
    '''Defines a sorted group of FORM, e.g. sequence of images. '''

    kFORM = ''
    '''Marks the start of a group of data blocks. '''

    kLIS4 = ''
    '''Four byte aligned LIST block. '''

    kCAT8 = ''
    '''Eight byte aligned CAT block. '''

    kFOR4 = ''
    '''Four byte aligned FORM block. '''

    def __eq__(self, tag): 
        '''__eq__(self, tag) -> bool

Arguments:
	[in]	tag = MIffTag

'''
        pass

class MImage:
    '''Image manipulation. This class provides methods for reading file images stored on disk.MImage is a class which provides access to some of Maya's image manipulation functionality. It has methods for loading and resizing image files in any Maya-supported raster format, including IFF, SGI, Softimage (pic), TIFF (tif), Alias PIX (als), GIF, RLA, JPEG (jpg). The image is stored as an uncompressed array of pixels, that can be read and manipulated directly. For simplicity, the pixels are stored in a RGBA format (4 bytes per pixel). '''
    def __init__(self):
        pass


    def setFloatPixels(self, inPixelPtr, width, height, channels): 
        '''setFloatPixels(self, inPixelPtr, width, height, channels)
Arguments:
	[in]	inPixelPtr = float
	[in]	width = int
	[in]	height = int
	[in]	channels = int


Set the pointer to the first pixel of the uncompressed pixels array. This array is tightly packed, of size (width * height * depth) bytes. For the moment, pixels are always stored in a RGBA (depth=4 bytes) pixel format.'''
        pass

    def filterExists(self, sourceFormat, targetFormat): 
        '''filterExists(self, sourceFormat, targetFormat) -> bool
Returns: true if the filter exists. 
false otherwise. 

Arguments:
	[in]	sourceFormat = MImage.MImageFilterFormat
	[out]	targetFormat = MImage.MImageFilterFormat


Return whether or not a given source format can be directly converted to a given target format. See  MImage::filter()  for more information.'''
        pass

    def getSize(self, width, height): 
        '''getSize(self, width, height)
Arguments:
	[out]	width = int
	[out]	height = int


Get the width and height of the currently opened image.'''
        pass

    def create(self, width, height, channels, type): 
        '''create(self, width, height, channels, type)
Arguments:
	[in]	width = int
	[in]	height = int
	[in]	channels = int
	[in]	type = MImage.MPixelType


Create a new  MImage  object. Allocates memory for an RGBA array of pixels of the given size. If an object was already in memory, it is released first.'''
        pass

    def readDepthMap(self, pathname): 
        '''readDepthMap(self, pathname)
Arguments:
	[in]	pathname = MString


Reads the depth map from the specified file and place the result into the depth map array of this  MImage  instance.'''
        pass

    def readFromTextureNode(self, fileTextureObject, type): 
        '''readFromTextureNode(self, fileTextureObject, type)
Arguments:
	[in]	fileTextureObject = MObject
	[in]	type = MImage.MPixelType


Attempt to read the content of the given file texture node. Please note that IFF and SGI are the fastest image file formats for reading.'''
        pass

    def writeToFile(self, pathname, outputFormat): 
        '''writeToFile(self, pathname, outputFormat)
Arguments:
	[in]	pathname = MString
	[in]	outputFormat = MString


Save the content of this image in a file. By default, the file is saved in IFF format. Optionally, the file can also be converted in a variety of image formats.'''
        pass

    def setPixels(self, inPixelPtr, width, height): 
        '''setPixels(self, inPixelPtr, width, height)
Arguments:
	[in]	inPixelPtr = char
	[in]	width = int
	[in]	height = int


Set the pointer to the first pixel of the uncompressed pixels array. This array is tightly packed, of size (width * height * depth) bytes. For the moment, pixels are always stored in a RGBA (depth=4 bytes) pixel format.'''
        pass

    def depthMap(self): 
        '''depthMap(self) -> float*
Returns: MS::kFailure - invalid object, or no depth data exists for this image instance. 
MS::kSuccess - depth buffer successfully returned. 


Returns a pointer to the depth data.'''
        pass

    def setRGBA(self, rgbaFormat): 
        '''setRGBA(self, rgbaFormat)
Arguments:
	[in]	rgbaFormat = bool


Sets a flag to indicate that pixel information is in RGBA sequence or BGRA sequence. Pixel data must have been allocated before this call is made.'''
        pass

    def readFromFile(self, pathname, type): 
        '''readFromFile(self, pathname, type)
Arguments:
	[in]	pathname = MString
	[in]	type = MImage.MPixelType


Attempt to identify and open the specified image file. Please note that IFF and SGI are the fastest image file formats for reading.'''
        pass

    def haveDepth(self): 
        '''haveDepth(self) -> bool


Returns true if this instance of  MImage  contains a depth map.'''
        pass

    def kUnknownFormat(self):
        '''This is an enum of MImageFilterFormat.
Description: 
Value: 3'''
        pass

    def kNormalMapBumpFormat(self):
        '''This is an enum of MImageFilterFormat.
Description: 
Value: 2'''
        pass

    def kHeightFieldBumpFormat(self):
        '''This is an enum of MImageFilterFormat.
Description: 
Value: 1'''
        pass

    def kNoFormat(self):
        '''This is an enum of MImageFilterFormat.
Description: 
Value: 0'''
        pass

    class MImageFilterFormat:
        '''Non-functional class.  Values for this enum:
        kUnknownFormat
        kNormalMapBumpFormat
        kHeightFieldBumpFormat
        kNoFormat
'''
        def __init__(self):
            pass

    def kByte(self):
        '''This is an enum of MPixelType.
Description: One byte per channel, ranging from 0 to 255.
Value: 1'''
        pass

    def kFloat(self):
        '''This is an enum of MPixelType.
Description: One float per channel, ranging from 0.0 to 1.0.
Value: 2'''
        pass

    def kUnknown(self):
        '''This is an enum of MPixelType.
Description: Format not known or invalid.
Value: 0'''
        pass

    class MPixelType:
        '''Non-functional class.  Values for this enum:
        kByte
        kFloat
        kUnknown
'''
        def __init__(self):
            pass

    def setDepthMap(self, depth, width, height): 
        '''setDepthMap(self, depth, width, height)
Arguments:
	[in]	depth = MFloatArray
	[in]	width = unsigned
	[in]	height = unsigned


Specifies the depth map resolution and data. Note, it is possible for the depth map to be a different resolution from the color map. This is to support oversampling with image planes. You cannot save image data to a file if the color map and image maps are different resolutions.'''
        pass

    def convertPixelFormat(self, format, scale, offset): 
        '''convertPixelFormat(self, format, scale, offset)
Arguments:
	[in]	format = MImage.MPixelType
	[in]	scale = double
	[in]	offset = double


Convert the pixel format used by this image using the specified parameters.'''
        pass

    def getDepthMapSize(self, width, height): 
        '''getDepthMapSize(self, width, height)
Arguments:
	[out]	width = int
	[out]	height = int


Returns the size of the depth map buffer. Note, depth maps can differ in resolution from the color map. This is mainly for oversampling support in image planes. In all other cases, you should insure that depth size matches the color buffer size. You cannot write out an image where the depth map and image map has different resolutions.'''
        pass

    def verticalFlip(self): 
        '''verticalFlip(self)

Flips the image vertically. 
  Reprocessed example  
 Examples: 
 
   
 cgfxShaderNode.cpp . 
 
'''
        pass

    def isRGBA(self): 
        '''isRGBA(self) -> bool


Query flag which indicates whether the pixel information is in RGBA sequence or BGRA sequence. If no pixel data exists, then false will be returned.'''
        pass

    def pixels(self): 
        '''pixels(self) -> char*


Returns a pointer to the first pixel of the uncompressed pixels array. This array is tightly packed, of size (width * height * depth) bytes. For the moment, pixels are always stored in a RGBA (depth=4 bytes) pixel format.'''
        pass

    def resize(self, width, height, preserveAspectRatio): 
        '''resize(self, width, height, preserveAspectRatio)
Arguments:
	[in]	width = int
	[in]	height = int
	[in]	preserveAspectRatio = bool


Resize the currently opened image to the specified dimension, or to the closest width/height that is preserves the original aspect ratio.'''
        pass

    def floatPixels(self): 
        '''floatPixels(self) -> float*


Returns a pointer to the first pixel of the uncompressed pixels array. This array is tightly packed, of size (width * height * depth * sizeof( float)) bytes.'''
        pass

    def pixelType(self): 
        '''pixelType(self) -> MImage.MPixelType


Get the current pixel format of the image.'''
        pass

    def filter(self, sourceFormat, targetFormat, scale, offset): 
        '''filter(self, sourceFormat, targetFormat, scale, offset)
Arguments:
	[in]	sourceFormat = MImage.MImageFilterFormat
	[in]	targetFormat = MImage.MImageFilterFormat
	[in]	scale = double
	[in]	offset = double


Modify the content of the image by applying a filter. The dimension of the image remains the same; only the RGBA components get affected.'''
        pass

    def depth(self): 
        '''depth(self) -> int


Get the color depth (in bytes) of the currently opened image.'''
        pass

    def writeToFileWithDepth(self, pathname, outputFormat, writeDepth): 
        '''writeToFileWithDepth(self, pathname, outputFormat, writeDepth)
Arguments:
	[in]	pathname = MString
	[in]	outputFormat = MString
	[in]	writeDepth = bool


Save the content of this image in a file. By default, the file is saved in IFF format. Optionally, the file can also be converted in a variety of image formats. If the writeDepth parameter is true then any depth information stored in  MImage  will be written to file.'''
        pass

    def release(self): 
        '''release(self)

Release the current image. If there is no current image, the call is ignored. An image is always released automatically during destruction, so generally there is no need to call this function manually.'''
        pass

class MImageFileInfo:
    '''Image manipulation. This class provides methods for reading file images stored on disk.MImageFileInfo is a utility class used to describe the characteristics of an image file, such as dimensions, channel count, and pixel format. This class is used in MPxImageFile. '''
    def __init__(self):
        pass


    def hasAlpha(self): 
        '''hasAlpha(self) -> bool


Query whether this image contains alpha information.'''
        pass

    def pixelType(self): 
        '''pixelType(self) -> MImage.MPixelType


Get the native pixel format of this image file.'''
        pass

    def hardwareType(self): 
        '''hardwareType(self) -> MImageFileInfo.MHwTextureType


Get the hardware texture type of this image file, describing whether this image contains a 2D texture, a cubemap, etc.'''
        pass

    def height(self): 
        '''height(self) -> int


Get the height in pixels of this image file.'''
        pass

    def channels(self): 
        '''channels(self) -> int


Get the number of channels in this image file.'''
        pass

    def width(self): 
        '''width(self) -> int


Get the width in pixels of this image file.'''
        pass

    def kImageTypeBump(self):
        '''This is an enum of MImageType.
Description: 
Value: 3'''
        pass

    def kImageTypeColor(self):
        '''This is an enum of MImageType.
Description: 
Value: 1'''
        pass

    def kImageTypeUnknown(self):
        '''This is an enum of MImageType.
Description: 
Value: 0'''
        pass

    def kImageTypeNormal(self):
        '''This is an enum of MImageType.
Description: 
Value: 2'''
        pass

    class MImageType:
        '''Non-functional class.  Values for this enum:
        kImageTypeBump
        kImageTypeColor
        kImageTypeUnknown
        kImageTypeNormal
'''
        def __init__(self):
            pass

    def hasMipMaps(self): 
        '''hasMipMaps(self) -> bool


Query whether this image contains or can generate mipmap information.'''
        pass

    def numberOfImages(self): 
        '''numberOfImages(self) -> int


Get the number of images in this image file.'''
        pass

    def kHwTexture1D(self):
        '''This is an enum of MHwTextureType.
Description: 
Value: 1'''
        pass

    def kHwTextureRectangle(self):
        '''This is an enum of MHwTextureType.
Description: 
Value: 4'''
        pass

    def kHwTexture3D(self):
        '''This is an enum of MHwTextureType.
Description: 
Value: 3'''
        pass

    def kHwTexture2D(self):
        '''This is an enum of MHwTextureType.
Description: 
Value: 2'''
        pass

    def kHwTextureCubeMap(self):
        '''This is an enum of MHwTextureType.
Description: 
Value: 5'''
        pass

    def kHwTextureUnknown(self):
        '''This is an enum of MHwTextureType.
Description: 
Value: 0'''
        pass

    class MHwTextureType:
        '''Non-functional class.  Values for this enum:
        kHwTexture1D
        kHwTextureRectangle
        kHwTexture3D
        kHwTexture2D
        kHwTextureCubeMap
        kHwTextureUnknown
'''
        def __init__(self):
            pass

    def imageType(self): 
        '''imageType(self) -> MImageFileInfo.MImageType


Query the type of information in this image file (e.g. is it a color map, a normal map, etc). Most image file formats do not contain this information, meaning this will be left as kImageTypeUnknown.'''
        pass

class MIntArray:
    '''Array of integers data type. This class implements an array of integers. Common convenience functions are available, and the implementation is compatible with the internal Maya implementation so that it can be passed efficiently between plugins and internal maya data structures. '''
    def __init__(self):
        pass


    def insert(self, element, index): 
        '''insert(self, element, index)
Arguments:
	[in]	element = int
	[in]	index = int


Inserts a new value into the array at the given index. The initial element at that index, and all following elements, are shifted towards the last. If the array cannot be expanded in size by 1 element, then the insert will fail and the existing array will remain unchanged.'''
        pass

    def set(self, element, index): 
        '''set(self, element, index)
Arguments:
	[in]	element = int
	[in]	index = int


Sets the value of the indicated element to the indicated value.'''
        pass

    def get(self, array): 
        '''get(self, array)
Arguments:
	[out]	array = int


Copy the elements of the array into the given C++ array of ints. No checking is done to ensure that the destination C++ array of ints is large enough to hold all the elements of the instance.'''
        pass

    def clear(self): 
        '''clear(self)

Clear the contents of the array. After this operation the length method will return 0. This does not change the amount of memory allocated to the array, only the number of valid elements in it.'''
        pass

    def sizeIncrement(self): 
        '''sizeIncrement(self) -> int


Return the size by which the array will be expanded whenever expansion is necessary.'''
        pass

    def remove(self, index): 
        '''remove(self, index)
Arguments:
	[in]	index = int


Remove the array element at the given index. All array elements following the removed element are shifted toward the first element.'''
        pass

    def length(self): 
        '''length(self) -> int


Returns the number of elements in the instance.'''
        pass

    def setSizeIncrement(self, newIncrement): 
        '''setSizeIncrement(self, newIncrement)
Arguments:
	[in]	newIncrement = int


Set the size by which the array will be expanded whenever expansion is necessary.'''
        pass

    def copy(self, source): 
        '''copy(self, source)
Arguments:
	[in]	source = MIntArray


Copy the contents of the source array to this array.'''
        pass

    def setLength(self, length): 
        '''setLength(self, length)
Arguments:
	[in]	length = int


Set the length of the array. This will grow and shrink the array as desired. Elements that are grown have uninitialized values, while those which are shrunk will lose the data contained in the deleted elements (ie. it will release the memory).'''
        pass

    def append(self, element): 
        '''append(self, element)
Arguments:
	[in]	element = int


Adds a new element to the end of the array. If the array cannot be expanded in size by 1 element, then the append will fail and the existing array will remain unchanged.'''
        pass

class MIteratorType:
    '''MIteratorType class. The MIteratorType class is used on iterators where more than one type of filters can be specified. It also provides functionalities to set and get the filter list or individual types of filter. This class should be used in conjunction with DAG/DG/DependencyNodes iterators for using filter list (list of MFn::Type objects) on them, thus enabling faster traversal thro' iterators.Also, the class has functionalities for specifying the type of object the iterator will be reset to. This could be an MObject, an MPlug or an MDagPath. '''
    def __init__(self):
        pass


    def getFilterType(self): 
        '''getFilterType(self) -> MFn.Type
Returns: The filter type.


Returns the type of filter.'''
        pass

    def kMPlugObject(self):
        '''This is an enum of objFilterType.
Description: This is to indicate that the root of the iterator has to be reset to an
Value: 2'''
        pass

    def kMObject(self):
        '''This is an enum of objFilterType.
Description: This is to indicate that the root of the iterator has to be reset to an
Value: 0'''
        pass

    def kMDagPathObject(self):
        '''This is an enum of objFilterType.
Description: This is to indicate that the root of the iterator has to be reset to an
Value: 1'''
        pass

    class objFilterType:
        '''Non-functional class.  Values for this enum:
        kMPlugObject
        kMObject
        kMDagPathObject
'''
        def __init__(self):
            pass

    def setFilterType(self, type): 
        '''setFilterType(self, type)
Arguments:
	[in]	type = MFn.Type


Sets the filter type to be used in the iterator. See  MFn::Type  for the list of filter types that can be set.'''
        pass

    def filterListEnabled(self): 
        '''filterListEnabled(self) -> bool


Returns whether the we are using a single filter on the iterator or a filter list.'''
        pass

    def getFilterList(self, listOfFilters): 
        '''getFilterList(self, listOfFilters)
Arguments:
	[out]	listOfFilters = MIntArray


Gets the list of filters.'''
        pass

    def setFilterList(self, listOfFilters): 
        '''setFilterList(self, listOfFilters)
Arguments:
	[in]	listOfFilters = MIntArray


Sets the filter list. The types of filters to be traversed in the iterator is added to an array and then passed in to this function. This also enables filter list usage on iterators, as opposed to single filter.'''
        pass

    def setObjectType(self, objFilterType): 
        '''setObjectType(self, objFilterType)
Arguments:
	[in]	objFilterType = objFilterType


Sets the object type. This function should be used only when we want to reset the iterator root. Iterator root can be reset to either an  MObject , an  MDagPath  or to an  MPlug . For each of this, there is a corresponding enum value, which has to be used as an argument to this function.'''
        pass

    def getObjectType(self): 
        '''getObjectType(self) -> MIteratorType.objFilterType
Returns: The object type.


Returns the object type.'''
        pass

class MItCurveCV:
    '''Iterator for NURBS curve CVs. This class is the iterator class for NURBS curve control vertices (CVs). The iteration can be for a given curve or for a group of CVs. Translates the CVs for a curve in the X direction (world space).'''
    def __init__(self):
        pass


    def reset(self, curve, component): 
        '''reset(self, curve, component)
Arguments:
	[in]	curve = MDagPath
	[in]	component = MObject


Reset the iterator to the specified curve and component. The component is a group of CVs belonging to the specified curve. The component defaults to  MObject::kNullObj . If a component is not given then the iterator will be reset for the whole curve.'''
        pass

    def index(self): 
        '''index(self) -> int
Returns: The index of the current CV


This method returns the index of the current CV in the CV array for this curve.'''
        pass

    def hasHistoryOnCreate(self): 
        '''hasHistoryOnCreate(self) -> bool


This method determines if the shape was created with history.'''
        pass

    def updateCurve(self): 
        '''updateCurve(self)

This method is used to signal the curve that it has been changed and needs to redraw itself.'''
        pass

    def translateBy(self, vec, space): 
        '''translateBy(self, vec, space)
Arguments:
	[in]	vec = MVector
	[in]	space = MSpace.Space


Translates the current CV by the amount sepcified in  vec .'''
        pass

    def next(self): 
        '''next(self)

Advance to the next CV in the iteration. If the iterator is already at the last CV then this method has no effect. Use  isDone  to determine if the iterator is at the last CV.'''
        pass

    def currentItem(self): 
        '''currentItem(self) -> MObject
Returns: A handle to the CV requested


This method returns the current CV as an  MObject .'''
        pass

    def position(self, space): 
        '''position(self, space) -> MPoint
Returns: Status code

Arguments:
	[in]	space = MSpace.Space


Return the position of the current CV.'''
        pass

    def setPosition(self, pt, space): 
        '''setPosition(self, pt, space)
Arguments:
	[in]	pt = MPoint
	[in]	space = MSpace.Space


Set the position of the current CV to the specified point.'''
        pass

    def isDone(self): 
        '''isDone(self) -> bool
Returns: Boolean value: true if there are no more CVs to iterate on, false otherwise.


Returns  true  if the iteration is finished, i.e. there are no more CVs to iterate on.'''
        pass

class MItDag:
    '''DAG Iterator. Use the DAG iterator to traverse the DAG either depth first or breadth first, visiting each node and, if desired, retrieving the node (as an MObject). The DAG iterator provides a basic filtering capability, so that DAG node retrieval can be limited to a specific type (MFn::Type) of node. With filtering enabled the iterator checks to see if the node is compatible with the type of Function Set specified by the filter. See MFn::Type for a list of all valid Function set types.Since each object, if retrieved, is returned as an MObject, the MObject::hasFn() method can be used to further check for compatible function set types since an MObjects may be compatible with more than one function set).Any compatible Function Set can be attached to the retrieved object to query or or edit it. Often you will want to use the DAG node Function Set (MFnDagNode), which is compatible with all DAG objects, to perform basic queries on each node as the iterator traverses the DAG.The iterator also provides the capability to reset the root of the iteration, the type of traversal, and the filter.Additionally, the iterator can be queried for the root, mode and type of traversal, and to determine if the the traversal has been completed. '''
    def __init__(self):
        pass


    def reset(self, dagInfoObject, object, path, type): 
        '''reset(self, dagInfoObject, object, path, type)
Arguments:
	[in]	dagInfoObject = MIteratorType
	[in]	object = MObject
	[in]	path = MDagPath
	[in]	type = MItDag.TraversalType


Resets root, type and filter list of the iterator. This method is usefull when a node is instanced and a DAG path is necessary to specify which instance should be the root of the traversal.'''
        pass

    def fullPathName(self): 
        '''fullPathName(self) -> MString
Returns: The full path name


Return a string representing the full path from the root of the dag to this object.'''
        pass

    def prune(self): 
        '''prune(self)

Prunes iteration tree at current node.'''
        pass

    def traverseUnderWorld(self, flag): 
        '''traverseUnderWorld(self, flag)
Arguments:
	[in]	flag = bool


Specifies whether underworld traversal is turned on. The default is off.'''
        pass

    def isInstanced(self, indirect): 
        '''isInstanced(self, indirect) -> bool
Returns: true = Node is instanced (directly or indirectly according to indirect instance flag) 
false = Node is not instanced (directly or indirectly according to indirect instance flag)

Arguments:
	[in]	indirect = bool


Determines whether the current item (DAG node) in the iteration is directly or indirectly instanced.'''
        pass

    def getType(self): 
        '''getType(self) -> MItDag.TraversalType
Returns: kDepthFirst Recursively visits grandchildren of each child node 
kBreadthFirst Recursively visits each child/parent node before any grandchild/grandparent nodes


Returns the direction of the traversal.'''
        pass

    def partialPathName(self): 
        '''partialPathName(self) -> MString
Returns: The partial path name


Return a string representing the partial path from the root of the dag to this object.'''
        pass

    def getPath(self, path): 
        '''getPath(self, path)
Arguments:
	[out]	path = MDagPath


Determines a DAG Path to the current item in the iteration.'''
        pass

    def next(self): 
        '''next(self)

Moves to the next node matching the filter in the graph.'''
        pass

    def depth(self): 
        '''depth(self) -> int
Returns: Depth of the current node


Returns the height or depth of the current node in the DAG relative to the root node. The root node has a depth of zero.'''
        pass

    def instanceCount(self, total): 
        '''instanceCount(self, total) -> int

Arguments:
	[in]	total = bool


Determines the number of times the current item (DAG node) in the iteration is instanced.'''
        pass

    def willTraverseUnderWorld(self): 
        '''willTraverseUnderWorld(self) -> bool
Returns: Boolean: true if underworld traversal is on, false otherwise.


Returns true if this iterator will traverse into underworld items.'''
        pass

    def getAllPaths(self, paths): 
        '''getAllPaths(self, paths)
Arguments:
	[out]	paths = MDagPathArray


Determines all DAG Paths to current item in the iteration.'''
        pass

    def currentItem(self): 
        '''currentItem(self) -> MObject
Returns: Pointer to the DAG node. Null pointer indicates failure.


Retrieves DAG node to which the iterator points.'''
        pass

    def kInvalidType(self):
        '''This is an enum of TraversalType.
Description: 
Value: 0'''
        pass

    def kBreadthFirst(self):
        '''This is an enum of TraversalType.
Description: Visit a node's siblings before moving on to its children.
Value: 2'''
        pass

    def kDepthFirst(self):
        '''This is an enum of TraversalType.
Description: Visit a node's children before moving on to its siblings.
Value: 1'''
        pass

    class TraversalType:
        '''Non-functional class.  Values for this enum:
        kInvalidType
        kBreadthFirst
        kDepthFirst
'''
        def __init__(self):
            pass

    def root(self): 
        '''root(self) -> MObject
Returns: Root of the traversal


Returns the root (start node) of the current traversal. The constructor sets the root of traversal to the world node. The root can be changed by the  reset()  method.'''
        pass

    def isDone(self): 
        '''isDone(self) -> bool
Returns: Boolean value: true when done, false otherwise.


Indicates end of iteration path.'''
        pass

class MItDependencyGraph:
    '''Dependency Graph Iterator. Iterate over Dependency Graph (DG) Nodes or Plugs starting at a specified root Node or Plug.Set and query the root of the iteration.Set and query the direction (downstream or upstream), traversal priority (depth first or breadth first) and level of detail (Node level or Plug level) of the iteration.Set and disable a filter to iterate over only speicifc types (MFn::Type) of Nodes.Reset the root, filter, direction, traversal priority and level of detail of the iteration.Prune branches of the graph from iteration.In Maya, all geometry, animation and rendering information is implemented in nodes in the Dependency Graph (DG). The DG includes the Directed Acyclic Graph (DAG). Therefore, all DAG nodes are also DG nodes. The data on nodes is associated with Attributes. Attributes on nodes are connected to Attributes on other nodes via plugs on the Attributes. Plugs are, in effect the external intefaces of Attributes.The DG Iterator Class (MItDependencyGraph) provides methods for iterating over either nodes or plugs, as well as methods for setting and querying the characteristics and behaviour of the iterator.This iterator will traverse all attributes upstream or downstream from the root node of the traversal. For non root nodes, only attributes that are affected by the incoming attribute to that node will be traversed. Hence, only nodes to which data from the root node is flowing will be traversed.The DG Iterator is used in conjunction with the Maya Object (MObject), plug (MPlug), Maya Object Array (MObjectArray) and plug Array (MPlugArray) classes.It is also useful to use Function Sets specific to the nodes returned by the iterator to query and modify the nodes in the DG.The DG itself can be modified using a DG Modifer (MDGModifier).Additionally, nodes can be added to and retrieved from selection lists using the Selection List (MSelectionList) class and Selection List Iterator (MItSelectionList). This can be useful for obtaining the root node for an iteration.Attributes on the nodes can be manipulated using the Attribute Function Set (MFnAttribute) and its derivations. '''
    def __init__(self):
        pass


    def toggleDirection(self): 
        '''toggleDirection(self)

Toggles the direction of the iteration. Resets the root of the iteration to the current node or plug depending on the level of iteration. Clears iterator path data. If a valid filter is enabled, the iterator automatically advances to the next node that matches the filter. If no matching node is found the status is failure (MFn::kFailure). No other iterator parameters are affected.'''
        pass

    def rootPlug(self): 
        '''rootPlug(self) -> MPlug
Returns: The root plug


Retrieves the root plug of the iteration.'''
        pass

    def getNodePath(self, path): 
        '''getNodePath(self, path)
Arguments:
	[out]	path = MObjectArray


Retrieves the direct path from the current node to the root node. Path does not include the current node. State of the provided array is undefined if this method fails.'''
        pass

    def currentTraversal(self): 
        '''currentTraversal(self) -> MItDependencyGraph.Traversal
Returns: MItDependencyGraph::kDepthFirst Traversal is depth first 
MItDependencyGraph::kBreadthFirst Traversal is breadth first


Reports the traversal mode of the iteration through the graph.'''
        pass

    def previousPlug(self): 
        '''previousPlug(self) -> MPlug
Returns: Current plug


Retrieves the previous plug of the iteration. Results in a null plug on failure. Null plug may also indicate that the current plug is the root plug.'''
        pass

    def currentDirection(self): 
        '''currentDirection(self) -> MItDependencyGraph.Direction
Returns: MItDependencyGraph::kDownstream Direction is downstream 
MItDependencyGraph::kDownstream Direction is upstream


Reports the direction of the iteration through the graph.'''
        pass

    def resetTo(self, rootNode, rootPlug, infoObject, direction, traversal, level): 
        '''resetTo(self, rootNode, rootPlug, infoObject, direction, traversal, level)
Arguments:
	[in]	rootNode = MObject
	[in]	rootPlug = MPlug
	[in]	infoObject = MIteratorType
	[in]	direction = MItDependencyGraph.Direction
	[in]	traversal = MItDependencyGraph.Traversal
	[in]	level = MItDependencyGraph.Level


Clears iterator data and re-initializes the iterator. The filter list is reset to the new list specified thro'  MIteratorType  object. If a valid filter is enabled, the iterator automatically advances to the next node after the root node/plug that matches the filter. If no matching node is found the status is failure (MFn::kFailure).'''
        pass

    def next(self): 
        '''next(self)

Iterates to the next node or plug in accordance with the direction, traversal, level and filter. If a valid filter is set, the iterator only visits those nodes that match the filter. When filtering is enabled nodes that have unknown type are treated as non-matching nodes. With filtering disabled, iteration to a node with an unknown type is treated as a failure. An attempt to iterate when there is nothing left to iterate over results in failure.'''
        pass

    def currentFilter(self): 
        '''currentFilter(self) -> MFn.Type
Returns: The current node type filter


Retrieves the current node type filter.'''
        pass

    def kDownstream(self):
        '''This is an enum of Direction.
Description: From source to destination.
Value: 0'''
        pass

    def kUpstream(self):
        '''This is an enum of Direction.
Description: From destination to source.
Value: 1'''
        pass

    class Direction:
        '''Non-functional class.  Values for this enum:
        kDownstream
        kUpstream
'''
        def __init__(self):
            pass

    def getPlugPath(self, path): 
        '''getPlugPath(self, path)
Arguments:
	[out]	path = MPlugArray


Retrieves the direct path from the current plug to the root plug. Path does not include the current plug. State of the provided array is undefined if this method fails.'''
        pass

    def isPruningOnFilter(self): 
        '''isPruningOnFilter(self) -> bool
Returns: Bool: true if pruning is enabled, false otherwise.


Tests whether or not the iteration path is pruned automatically at nodes or plugs which do not match the filter.'''
        pass

    def enablePruningOnFilter(self): 
        '''enablePruningOnFilter(self)

Enables automatic pruning of iteration path at nodes or plugs which do not match the filter.'''
        pass

    def kBreadthFirst(self):
        '''This is an enum of Traversal.
Description: Equidistant from root first.
Value: 1'''
        pass

    def kDepthFirst(self):
        '''This is an enum of Traversal.
Description: Away from root first.
Value: 0'''
        pass

    class Traversal:
        '''Non-functional class.  Values for this enum:
        kBreadthFirst
        kDepthFirst
'''
        def __init__(self):
            pass

    def isTraversalDepthFirst(self): 
        '''isTraversalDepthFirst(self) -> bool
Returns: true Traversal is depth first (MItDependencyGraph::kDepthFirst) 
false Traversal is breadth first (MItDependencyGraph::kBreadthFirst)


Tests whether or not the iteration is proceeding depth first (away from the root of the iteration) in the DG.'''
        pass

    def currentItem(self): 
        '''currentItem(self) -> MObject
Returns: Current node


Retrieves the current node of the iteration. Results in a null object on failure or if the node is of a unrecognized type.'''
        pass

    def isDone(self): 
        '''isDone(self) -> bool
Returns: true Iteration is done 
false Iteration is not done


Indicates whether or not all nodes or plugs have been iterated over in accordance with the direction, traversal, level and filter. If a valid filter is set, the iterator only visits those nodes that match the filter.'''
        pass

    def thisNodeHasUnknownType(self): 
        '''thisNodeHasUnknownType(self) -> bool
Returns: true Unknown type 
false Type is known or iterator is done or failure encountered


Indicates whether or not the current node has an unrecognised type. This is useful if an unexpected failure is encountered in the  next()  or  thisNode()  methods.'''
        pass

    def thisPlug(self): 
        '''thisPlug(self) -> MPlug
Returns: Current plug


Retrieves the current plug of the iteration. Results in a null plug on failure.'''
        pass

    def currentLevel(self): 
        '''currentLevel(self) -> MItDependencyGraph.Level
Returns: MItDependencyGraph::kNodeLevel Level is node level 
MItDependencyGraph::kPlugLevel Level is plug level


Reports the level of the iteration through the graph.'''
        pass

    def getNodesVisited(self, nodes): 
        '''getNodesVisited(self, nodes)
Arguments:
	[out]	nodes = MObjectArray


Retrieves all nodes visited during the iteration. State of the provided array is undefined if this method fails.'''
        pass

    def kNodeLevel(self):
        '''This is an enum of Level.
Description: Visit each Node at most once.
Value: 0'''
        pass

    def kPlugLevel(self):
        '''This is an enum of Level.
Description: Visit each Plug at most once.
Value: 1'''
        pass

    class Level:
        '''Non-functional class.  Values for this enum:
        kNodeLevel
        kPlugLevel
'''
        def __init__(self):
            pass

    def disablePruningOnFilter(self): 
        '''disablePruningOnFilter(self)

Disables automatic pruning of iteration path at nodes or plugs which do not match the filter.'''
        pass

    def getPlugsVisited(self, plugs): 
        '''getPlugsVisited(self, plugs)
Arguments:
	[out]	plugs = MPlugArray


Retrieves all plugs visited during the iteration. State of the provided array is undefined if this method fails.'''
        pass

    def toggleTraversal(self): 
        '''toggleTraversal(self)

Toggles the traversal of the iteration. Resets the root of the iteration to the current node or plug depending on the level of iteration. Clears iterator path data. If a valid filter is enabled, the iterator automatically advances to the next node that matches the filter. If no matching node is found the status is failure (MFn::kFailure). No other iterator parameters are affected.'''
        pass

    def resetFilter(self): 
        '''resetFilter(self)

Resets the node or plug filter to default,  MFn::kInvalid  (filter disabled). Disables pruning on the filter (default). Resets the iterator.'''
        pass

    def setCurrentFilter(self, filter): 
        '''setCurrentFilter(self, filter)
Arguments:
	[in]	filter = MFn.Type


Sets the node or plug filter. Plug filtering is based on the type of the corresponding Attribute. Defaults to disabled ( MFn::kInvalid ). If a valid filter is specified, the iterator automatically advances to the next node that matches the filter. If no matching node status is failure (MFn::kFailure).'''
        pass

    def reset(self): 
        '''reset(self)

Clears iterator data and resets the iterator to the root node or plug. If a valid filter is enabled, the iterator automatically advances to the next node after the root node that matches the filter. If no matching node is found the status is failure (MFn::kFailure).'''
        pass

    def prune(self): 
        '''prune(self)

Prunes the search path at the current plug. Iterator will not visit any of the plugs connected to the pruned plug.'''
        pass

    def isDirectionDownStream(self): 
        '''isDirectionDownStream(self) -> bool
Returns: true Direction is downstream (MItDependencyGraph::kDownstream) 
false Direction is upstream (MItDependencyGraph::kUpstream)


Tests whether or not the iteration is moving downstream (in the direction of data flow) in the DG.'''
        pass

    def rootNode(self): 
        '''rootNode(self) -> MObject
Returns: The root node


Retrieves the root node of the iteration.'''
        pass

    def atNodeLevel(self): 
        '''atNodeLevel(self) -> bool
Returns: true node level (MItDependencyGraph::kNodeLevel) 
false plug level (MItDependencyGraph::kPlugLevel)


Tests whether or not the iteration is at the node level of detail (every node is visited only once) in the DG.'''
        pass

    def toggleLevel(self): 
        '''toggleLevel(self)

Toggles the level of the iteration. Resets the root of the iteration to the current node or plug depending on the level of iteration. Clears iterator path data. If a valid filter is enabled, the iterator automatically advances to the next node that matches the filter. If no matching node is found the status is failure (MFn::kFailure). No other iterator parameters are affected.'''
        pass

class MItDependencyNodes:
    '''Dependency Node iterator. Use the dependency node iterator to traverse all the nodes in Maya's Dependency Graph.With filtering enabled, the iterator checks to see if the node is compatible with the type specified by the filter. See MFn::Type for a list of all valid types.Since MObjects may be compatible with more than one type (nodes are organised in a hierarchy) the MObject::hasFn() method can be used to further check for compatible types.Any compatible Function Set can be attached to the retrieved object to query or or edit it. Often you will want to use the dependency node function set (MFnDependencyNode), which is compatible with all dependency nodes, to perform queries on each node as the iterator Traverses the Dependency Graph. '''
    def __init__(self):
        pass


    def reset(self, infoObject): 
        '''reset(self, infoObject)
Arguments:
	[in]	infoObject = MIteratorType


Resets the iterator and reinitializes the filter list. The filter list is specified through  MIteratorType  object.'''
        pass

    def thisNode(self): 
        '''thisNode(self) -> MObject
Returns: The dependency node. A null MObject indicates failure.


Retrieves the dependency node to which the iterator points.'''
        pass

    def isDone(self): 
        '''isDone(self) -> bool
Returns: Bool: true if the iteration is done, false otherwise


Indicates end of the iteration.'''
        pass

    def next(self): 
        '''next(self)

Moves to the next node matching the filter. If the filter is set to kInvalid, this method advances to the next DG node without doing any filtering.'''
        pass

class MItGeometry:
    '''Iterator class for geometry data. This class is the iterator class for geometry data, and can be used to loop over the CVs of NURBS, the points of subds & lattices, and the vertices of polygonal meshes.Traversal of a geometry group within a compute() method.'''
    def __init__(self):
        pass


    def count(self): 
        '''count(self) -> int
Returns: The number of items that will be iterated


Return the number of items in this iteration. This number will always be at least as large as the number of items, however in some cases it may be larger. It is useful if allocating space in an array to hold the results, since it will always be of sufficient size. If the exact number of items is required, use the exactCount method instead. The exactCount method is however significantly slower than this method.'''
        pass

    def index(self): 
        '''index(self) -> int
Returns: The index of the current point/CV/vertex.


This method returns the index of the current point/CV/vertex component in the iteration.'''
        pass

    def exactCount(self): 
        '''exactCount(self) -> int
Returns: The number of items that will be iterated


Return the exact number of items in this iteration. This method is significantly slower than the  count()  method, so use if only if the precise number is required.'''
        pass

    def weight(self): 
        '''weight(self) -> MWeight
Returns: The current component's weight 


Return the weight of the current point/CV/vertex component.'''
        pass

    def next(self): 
        '''next(self)

Advance to the next component in the iteration. If the iterator is already at the last component then this method has no effect. Use  isDone  to determine if the iterator is at the last component.'''
        pass

    def reset(self): 
        '''reset(self)

Reset the iterator to the first component.'''
        pass

    def currentItem(self): 
        '''currentItem(self) -> MObject
Returns: The current component in the iteration.


This method returns the current component in the iteration.'''
        pass

    def position(self, space): 
        '''position(self, space) -> MPoint
Returns: Status code

Arguments:
	[in]	space = MSpace.Space


Return the position of the current point/CV/vertex component.'''
        pass

    def setPosition(self, pt, space): 
        '''setPosition(self, pt, space)
Arguments:
	[in]	pt = MPoint
	[in]	space = MSpace.Space


Set the position of the current point/CV/vertex.'''
        pass

    def setAllPositions(self, pt, space): 
        '''setAllPositions(self, pt, space)
Arguments:
	[in]	pt = MPointArray
	[in]	space = MSpace.Space


Set the position of all the points/CVs/vertices at once. This operation is faster than using the iterator to set values one by one, but uses more memory as it requires an array to hold all the values to be set.'''
        pass

    def isDone(self): 
        '''isDone(self) -> bool
Returns: Bool true if There are no more components to iterate on, false otherwise.


Returns  true  if the iteration is finished, i.e. there are no more components to iterate on.'''
        pass

    def allPositions(self, space, points): 
        '''allPositions(self, space, points)
Arguments:
	[out]	points = MPointArray
	[in]	space = MSpace.Space


Return the position of all the points/CVs/vertices. This operation is faster than using the iterator to get values one by one, but uses more memory as it requires an array to hold all the values to be returned.'''
        pass

class MItInstancer:
    '''Particle iterator. Maya's Particle Replacement aka Particle Instancing feature allows geometry to be instanced and those instances transformed using particles. More precisely, particles are replaced by arbitrary DAG nodes which maya be transforms with many shapes under them, and multiple DAG paths to those shapes.The Instancer Iterator Class (MItInstancer) provides methods for iterating over all the dag paths to the shapes created in the scene by the replacement of particles by dag nodes.When particles are being replaced by a shape node there will be one dag path corresponding with each particle. If, say, particles are instead being replaced by a transform with five shape nodes somewhere underneath it, then this iterator will visit five paths for every particle. Dag-instancing is also respected: if the given dag node has two child transforms each of which is a path to one shape underneath them, then this iterator will visit two paths. In other words, this iterator does not distinguish between paths resulting from a multiplicity of actual shapes and paths resulting from DAG-instances of individual shapes: all appear as different paths for the current particle.A simple usage might look like:MItInstancer it; while( ! it.isDone() ) { MDagPath path = it.path(); MString label = path.fullPathName(); MGlobal::displayInfo( label ); it.next(); } '''
    def __init__(self):
        pass


    def reset(self): 
        '''reset(self)

Moves the iterator to the first dag-path to the first replaced-particle in the scene. If none exist, then  isDone()  will be immediately  true .'''
        pass

    def matrix(self): 
        '''matrix(self) -> MMatrix


Returns the transformation matrix represented by the current path. If there is no such path, identity matrix will be returned.'''
        pass

    def particleId(self): 
        '''particleId(self) -> int


Returns a unique identifier for the current particle. Collectively, this id together with the instancer id and the path id uniquely identify a "replaced particle".'''
        pass

    def instancerPath(self): 
        '''instancerPath(self) -> MDagPath


Returns the full DAG path to the instancer that generated the current particle instance.'''
        pass

    def nextParticle(self): 
        '''nextParticle(self)

Advances the iterator to the next replaced-particle in the scene, skipping over any remaining dag-paths associated with the current replaced-particle.'''
        pass

    def next(self): 
        '''next(self)

Advances the iterator to the next replaced-particle dag-path in the scene. Calling  reset() , then repeatedly calling this method until  isDone()  becomes  true  is equivalent to the following loop structure:'''
        pass

    def instancer(self): 
        '''instancer(self) -> MObject


Returns the current instancer node as an  MObject .'''
        pass

    def nextInstancer(self): 
        '''nextInstancer(self)

Advances the iterator to the next instancer in the scene, skipping over any remaining particles associated with the current instancer.'''
        pass

    def instancerId(self): 
        '''instancerId(self) -> MUintPtrSz


Returns a unique identifier for the current instancer. Collectively, this id together with the particle id and the path id uniquely identify a "replaced particle".'''
        pass

    def pathId(self): 
        '''pathId(self) -> int


Returns a unique identifier for the current path. Collectively, this id together with the instancer id and the particle id uniquely identify a "replaced particle".'''
        pass

    def path(self): 
        '''path(self) -> MDagPath


Returns the replaced-particle dag-path which the iterator is currently pointing to. Each path is to a shape. If the particle is replaced by a shape directly then there will be only one path per particle. If a particle is replaced by a transform with many child shapes then each one of those shapes will have a path. Amongst the paths corresponding to a given particle there may be multiple paths to multiple shapes. If there is no such path, a null path will be returned.'''
        pass

    def isDone(self): 
        '''isDone(self) -> bool


Returns  true  if the iteration is finished, i.e. there are no more dag-paths to replaced-particles in the scene.'''
        pass

class MItMeshEdge:
    '''Polygon edge iterator. This class is the edge iterator for polygonal surfaces.The iterator functions in two modes depending on whether a component is specified. When a component is not given or is NULL the iteration will be over all edges for the polygon. When a component is given this iterator will iterate over the edges specified in the component. When iterating over components a DAG path to the polygon must also be supplied. '''
    def __init__(self):
        pass


    def onBoundary(self): 
        '''onBoundary(self) -> bool
Returns: Boolean value: true if it's a border edge, false otherwise.


This method checks to see if the current edge is a border edge.'''
        pass

    def connectedToEdge(self, index): 
        '''connectedToEdge(self, index) -> bool

Arguments:
	[in]	index = int


This method determines whether the given edge is connected to the current edge'''
        pass

    def point(self, index, space): 
        '''point(self, index, space) -> MPoint
Returns: The position of the edge vertex for the given index

Arguments:
	[in]	index = int
	[in]	space = MSpace.Space


Return the position of the specified vertex of the current edge.'''
        pass

    def getConnectedFaces(self, faces): 
        '''getConnectedFaces(self, faces) -> int

Arguments:
	[in]	faces = MIntArray


This method returns a list of faces (with 1 or 2 faces) connected to teh current edge.'''
        pass

    def setSmoothing(self, smooth): 
        '''setSmoothing(self, smooth)
Arguments:
	[in]	smooth = bool


This method sets the current edge to be hard or smooth (soft). The  cleanupSmoothing  method is no longer required to be called after setSmoothing in Maya3.0 and later versions.'''
        pass

    def setIndex(self, index, prevIndex): 
        '''setIndex(self, index, prevIndex)
Arguments:
	[in]	index = int
	[in]	prevIndex = int


This method sets the index of the current edge to be accessed. The current edge will no longer be in sync with any previous iteration. two vertices.'''
        pass

    def connectedToFace(self, index): 
        '''connectedToFace(self, index) -> bool

Arguments:
	[in]	index = int


This method determines whether the given face contains the current edge'''
        pass

    def geomChanged(self): 
        '''geomChanged(self)

Reset the geom pointer in the  MItMeshEdge . If you're using  MFnMesh  to update Normals or Color per vertex while iterating, you must call geomChanged on the iterator immediately after the  MFnMesh  call to make sure that your geometry is up to date. A crash may result if this method is not called.'''
        pass

    def index(self): 
        '''index(self) -> int
Returns: The index of the current edge in the iteration


This method returns the index of the current edge in the iteration.'''
        pass

    def getLength(self, space, length): 
        '''getLength(self, space, length)
Arguments:
	[out]	length = double
	[in]	space = MSpace.Space


This method returns the length of the current edge.'''
        pass

    def next(self): 
        '''next(self)

Advance to the next edge in the iteration.'''
        pass

    def numConnectedEdges(self, edgeCount): 
        '''numConnectedEdges(self, edgeCount)
Arguments:
	[in]	edgeCount = int


This method returns the number of edges connected to the current edge.'''
        pass

    def currentItem(self): 
        '''currentItem(self) -> MObject
Returns: The current edge in the interation


Get the current edge in the iteration as a component.'''
        pass

    def isDone(self): 
        '''isDone(self) -> bool
Returns: Boolean value: true All edges have been traversed, false otherwise.


Indicates if all of the edges have been traversed yet.'''
        pass

    def count(self): 
        '''count(self) -> int
Returns: The number of edges in the iteration


Return the number of edges in this iteration.'''
        pass

    def updateSurface(self): 
        '''updateSurface(self)

Signal that this polygonal surface has changed and needs to redraw itself.'''
        pass

    def reset(self, polyObject, component): 
        '''reset(self, polyObject, component)
Arguments:
	[in]	polyObject = MDagPath
	[in]	component = MObject


Reset the iterator to the first edge in the supplied mesh. Uses the edges constrained by the given component. If component is null then the iteration will be for all edges in the given polygon.'''
        pass

    def center(self, space): 
        '''center(self, space) -> MPoint

Arguments:
	[in]	space = MSpace.Space


Returns the center of the current edge.'''
        pass

    def setPoint(self, point, index, space): 
        '''setPoint(self, point, index, space)
Arguments:
	[in]	point = MPoint
	[in]	index = int
	[in]	space = MSpace.Space


Set the specified vertex of the current edge to the given value.'''
        pass

    def getConnectedEdges(self, edges): 
        '''getConnectedEdges(self, edges) -> int

Arguments:
	[in]	edges = MIntArray


This method returns a list of edges connected to the current edge.'''
        pass

    def isSmooth(self): 
        '''isSmooth(self) -> bool
Returns: Boolean value: true if the edge is smooth (soft), false if the edge is hard.


This method determines if the current edge in the iteration is smooth (soft).'''
        pass

    def numConnectedFaces(self, faceCount): 
        '''numConnectedFaces(self, faceCount)
Arguments:
	[out]	faceCount = int


This method returns the number of faces (1 or 2 ) connected to the current edge.'''
        pass

class MItMeshFaceVertex:
    '''Face vertex iterator. This class is the iterator for face vertices on polygonal surfaces.The iterator functions in two modes depending on whether a component is specified. When a component is not given or is NULL the iteration will be over all polygons for the surface. When a component is given this iterator will iterate over the polygons specified in the component. When iterating over components a DAG path to the surface must also be supplied. '''
    def __init__(self):
        pass


    def faceVertId(self): 
        '''faceVertId(self) -> int
Returns: The relative index of the current vertex.


Returns the relative index of the vertex within the current face. This index together with the faceId can be used for a fast access to get various info stored per vertex (normals, uvs, colors).'''
        pass

    def getTangent(self, space, uvSet): 
        '''getTangent(self, space, uvSet) -> MVector

Arguments:
	[in]	space = MSpace.Space
	[in]	uvSet = MString


Return the face vertex tangent associated with the given UV set. The tangent is defined as the surface tangent of the polygon running in the U direction.'''
        pass

    def setIndex(self, faceIndex, faceVertIndex, prevFaceId, prevVertId): 
        '''setIndex(self, faceIndex, faceVertIndex, prevFaceId, prevVertId)
Arguments:
	[in]	faceIndex = int
	[in]	faceVertIndex = int
	[in]	prevFaceId = int
	[in]	prevVertId = int


This method sets the index of the current face vertex to be accessed. The current face vertex will no longer be in sync with any previous iteration.'''
        pass

    def getUVIndex(self, uvSet, index, u, v): 
        '''getUVIndex(self, uvSet, index, u, v)
Arguments:
	[out]	index = int
	[out]	u = float
	[out]	v = float
	[in]	uvSet = MString


Return the index of the texture coordinate for the current face vertex. This index refers to an element of the texture coordinate array for the polygonal object returned by  MFnMesh::getUVs .'''
        pass

    def hasUVs(self, uvSet): 
        '''hasUVs(self, uvSet) -> bool
Returns: Boolean value: true if the face vertex has UV's mapped, false otherwise.

Arguments:
	[in]	uvSet = MString


Does this face vertex has UV's mapped or not in a given uv set.'''
        pass

    def geomChanged(self): 
        '''geomChanged(self)

Reset the geom pointer in the  MItMeshFaceVertex .'''
        pass

    def getBinormal(self, space, uvSet): 
        '''getBinormal(self, space, uvSet) -> MVector

Arguments:
	[in]	space = MSpace.Space
	[in]	uvSet = MString


Return the face vertex binormal associated with the UV set.'''
        pass

    def getColorIndex(self, colorSetName, colorIndex): 
        '''getColorIndex(self, colorSetName, colorIndex)
Arguments:
	[out]	colorIndex = int
	[in]	colorSetName = MString


Return a color index of the current face vertex.'''
        pass

    def next(self): 
        '''next(self)

Advance to the next face vertext in the iteration.'''
        pass

    def normalId(self): 
        '''normalId(self) -> int
Returns: The index of the normal for the current vertex


Returns the normal index for the specified vertex. This index refers to an element in the normal array returned by  MFnMesh::getNormals . These normals are per-polygon per-vertex normals. See the  MFnMesh  description for more information on normals.'''
        pass

    def currentItem(self): 
        '''currentItem(self) -> MObject
Returns: An MObject containing the double index.


Returns the double componet index of the vertex and face.'''
        pass

    def faceId(self): 
        '''faceId(self) -> int
Returns: The index of the current face.


Returns the current face index.'''
        pass

    def vertId(self): 
        '''vertId(self) -> int
Returns: The index of the current face vertex.


Returns the index of the current face vertex.'''
        pass

    def tangentId(self): 
        '''tangentId(self) -> int
Returns: The index of the tangnet for the current vertex


Returns the tangent (or binormal) index for the specified vertex. This index refers to an element in the normal array returned by  MFnMesh::getTangents . These tangent or binormals are per-polygon per-vertex. See the  MFnMesh  description for more information on tangents and binormals.'''
        pass

    def isDone(self): 
        '''isDone(self) -> bool
Returns: Boolean value: true All face vertices have been traversed, false otherwise.


Indicates if all of the face vertices have been traversed.'''
        pass

    def getColor(self, colorSetName, color): 
        '''getColor(self, colorSetName, color)
Arguments:
	[out]	color = MColor
	[in]	colorSetName = MString


Return a color of the current face vertex.'''
        pass

    def getUV(self, uvSet, uvPoint): 
        '''getUV(self, uvSet, uvPoint)
Arguments:
	[out]	uvPoint = float2
	[in]	uvSet = MString


Return the texture coordinate for the current face vertex.'''
        pass

    def reset(self, polyObject, component): 
        '''reset(self, polyObject, component)
Arguments:
	[in]	polyObject = MDagPath
	[in]	component = MObject


Reset the iterator with the given surface and component. If component is null then the iteration will be for all face vertices in the given surface.'''
        pass

    def updateSurface(self): 
        '''updateSurface(self)

Signal that this polygonal surface has changed and needs to redraw itself.'''
        pass

    def getNormal(self, space, normal): 
        '''getNormal(self, space, normal)
Arguments:
	[out]	normal = MVector
	[in]	space = MSpace.Space


Return the face vertex normal.'''
        pass

    def hasColor(self): 
        '''hasColor(self) -> bool
Returns: Boolean value: true if at least one vertex has color, false otherwise.


This method determines whether the current face vertex has color-per-vertex set.'''
        pass

    def position(self, space): 
        '''position(self, space) -> MPoint
Returns: The vertex position

Arguments:
	[in]	space = MSpace.Space


Return the position of the current face vertex.'''
        pass

class MItMeshPolygon:
    '''Polygon iterator. This class is the iterator for polygonal surfaces (meshes).The iterator functions in two modes depending on whether a component is specified. When a component is not given or is NULL the iteration will be over all polygons for the surface. When a component is given this iterator will iterate over the polygons (faces) specified in the component. When iterating over components a DAG path to the surface must also be supplied. '''
    def __init__(self):
        pass


    def isHoled(self): 
        '''isHoled(self) -> bool
Returns: Boolean value: true the face has one or more holes, false otherwise.


This method checks if the face has any holes.'''
        pass

    def onBoundary(self): 
        '''onBoundary(self) -> bool
Returns: Boolean value: true if on a boundary, false otherwise.


This method determines whether the current face is on a boundary'''
        pass

    def isPlanar(self): 
        '''isPlanar(self) -> bool
Returns: Boolean value: true the face is planar, false otherwise.


This method checks if the face is planar'''
        pass

    def getNormals(self, space, normalArray): 
        '''getNormals(self, space, normalArray)
Arguments:
	[out]	normalArray = MVectorArray
	[in]	space = MSpace.Space


Returns the normals for all vertices in the current face'''
        pass

    def isConvex(self): 
        '''isConvex(self) -> bool
Returns: Boolean value: true if the face is convex, false otherwise.


This method checks if the face is convex.'''
        pass

    def point(self, index, space): 
        '''point(self, index, space) -> MPoint
Returns: The vertex position

Arguments:
	[in]	index = int
	[in]	space = MSpace.Space


Return the position of the vertex at  index  in the current polygon.'''
        pass

    def getConnectedFaces(self, faces): 
        '''getConnectedFaces(self, faces)
Arguments:
	[out]	faces = MIntArray


This method gets the indices of the faces connected to the current face.'''
        pass

    def setUV(self, vertexId, uvPoint, uvSet): 
        '''setUV(self, vertexId, uvPoint, uvSet)
Arguments:
	[in]	vertexId = int
	[in]	uvPoint = float2
	[in]	uvSet = MString


Modify the UV value for the given vertex in the current face. If the face is not already mapped, this method will fail.'''
        pass

    def isConnectedToFace(self, index): 
        '''isConnectedToFace(self, index) -> bool
Returns: true if connected, false otherwise.

Arguments:
	[in]	index = int


This method determines whether the given face is adjacent to the current face'''
        pass

    def numTriangles(self, triCount): 
        '''numTriangles(self, triCount)
Arguments:
	[out]	triCount = int


This Method checks for the number of triangles in this face in the current triangulation'''
        pass

    def setIndex(self, index, prevIndex): 
        '''setIndex(self, index, prevIndex)
Arguments:
	[in]	index = int
	[in]	prevIndex = int


This method sets the index of the current face to be accessed. The current face will no longer be in sync with any previous iteration.'''
        pass

    def getConnectedEdges(self, edges): 
        '''getConnectedEdges(self, edges)
Arguments:
	[out]	edges = MIntArray


This method gets the indices of the edges connected to the vertices of the current face, but DOES not include the edges contained in the current face'''
        pass

    def setUVs(self, uArray, vArray, uvSet): 
        '''setUVs(self, uArray, vArray, uvSet)
Arguments:
	[in]	uArray = MFloatArray
	[in]	vArray = MFloatArray
	[in]	uvSet = MString


Modify the UV value for all vertices in the current face. If the face has not already been mapped, this method will fail.'''
        pass

    def hasColor(self, vertexIndex): 
        '''hasColor(self, vertexIndex) -> bool
Returns: Boolean value: true if the given vertex has color, false otherwise.

Arguments:
	[in]	vertexIndex = int


This method determines whether the current face has color-per-vertex set for the given vertex.'''
        pass

    def isLamina(self): 
        '''isLamina(self) -> bool
Returns: Boolean value: true if the face is a lamina, false otherwise.


This method checks if the face is a lamina (the face is folded over onto itself).'''
        pass

    def getUVIndex(self, vertex, uvSet, index, u, v): 
        '''getUVIndex(self, vertex, uvSet, index, u, v)
Arguments:
	[in]	vertex = int
	[out]	index = int
	[out]	u = float
	[out]	v = float
	[in]	uvSet = MString


Return the index of the texture coordinate for the given vertex. This index refers to an element of the texture coordinate array for the polygonal object returned by  MFnMesh::getUVs .'''
        pass

    def hasUVs(self, uvSet): 
        '''hasUVs(self, uvSet) -> bool
Returns: Boolean value: true if the face has UV's mapped, false otherwise

Arguments:
	[in]	uvSet = MString


Tests whether this face has UV's mapped or not (either all the vertices for a face should have UV's, or none of them do, so the UV count for a face is either 0, or equal to the number of vertices).'''
        pass

    def geomChanged(self): 
        '''geomChanged(self)

Reset the geom pointer in the  MItMeshPolygon . This is now being handled automatically inside the iterator, and users should no longer need to call this method directly to sync up the iterator to changes made by  MFnMesh'''
        pass

    def normalIndex(self, localVertexIndex): 
        '''normalIndex(self, localVertexIndex) -> int
Returns: The index of the normal for the specified vertex

Arguments:
	[in]	localVertexIndex = int


Returns the normal index for the specified vertex. This index refers to an element in the normal array returned by  MFnMesh::getNormals . These normals are per-polygon per-vertex normals. See the  MFnMesh  description for more information on normals.'''
        pass

    def getColorIndex(self, vertexIndex, colorSetName, colorIndex): 
        '''getColorIndex(self, vertexIndex, colorSetName, colorIndex)
Arguments:
	[in]	vertexIndex = int
	[out]	colorIndex = int
	[in]	colorSetName = MString


This method returns the current colorIndex.'''
        pass

    def index(self): 
        '''index(self) -> int
Returns: The index of the current polygon


Returns the index of the current polygon.'''
        pass

    def getVertices(self, vertices): 
        '''getVertices(self, vertices)
Arguments:
	[out]	vertices = MIntArray


This method gets the indices of the vertices of the current face'''
        pass

    def getArea(self, space, area): 
        '''getArea(self, space, area)
Arguments:
	[out]	area = double
	[in]	space = MSpace.Space


This method gets the area of the face'''
        pass

    def zeroUVArea(self, uvSet): 
        '''zeroUVArea(self, uvSet) -> bool
Returns: true if the face has zero UV area 
false otherwise.

Arguments:
	[in]	uvSet = MString


This method checks if the UV area of the face is zero'''
        pass

    def next(self): 
        '''next(self)

Advance to the next polygon in the iteration.'''
        pass

    def isConnectedToEdge(self, index): 
        '''isConnectedToEdge(self, index) -> bool
Returns: Boolean value: true if connected, false otherwise.

Arguments:
	[in]	index = int


This method determines whether the given edge is connected to a vertex in the current face'''
        pass

    def numConnectedEdges(self, edgeCount): 
        '''numConnectedEdges(self, edgeCount)
Arguments:
	[out]	edgeCount = int


This method checks for the number of connected edges on the vertices of this face'''
        pass

    def getColor(self, index, color): 
        '''getColor(self, index, color)
Arguments:
	[out]	color = MColor
	[in]	index = int


This method gets the color of the specifed vertex in this face'''
        pass

    def currentItem(self): 
        '''currentItem(self) -> MObject
Returns: The current polygon in the interation


Get the current polygon in the iteration as a component.'''
        pass

    def getEdges(self, edges): 
        '''getEdges(self, edges)
Arguments:
	[out]	edges = MIntArray


This method gets the indices of the edges contained in the current face.'''
        pass

    def isDone(self): 
        '''isDone(self) -> bool
Returns: Boolean value: true if all polygons have been traversed, false otherwise.


Indicates if all of the polygons have been traversed yet.'''
        pass

    def getUVAtPoint(self, pt, space, uvSet, uvPoint): 
        '''getUVAtPoint(self, pt, space, uvSet, uvPoint)
Arguments:
	[in]	pt = MPoint
	[out]	uvPoint = float2
	[in]	space = MSpace.Space
	[in]	uvSet = MString


Find the point closest to the given point in the current polygon, and return the UV value at that point.'''
        pass

    def count(self): 
        '''count(self) -> int
Returns: The number of polygons in the iteration


Return the number of polygons in the iteration.'''
        pass

    def tangentIndex(self, localVertexIndex): 
        '''tangentIndex(self, localVertexIndex) -> int
Returns: The index of the tangent for the specified vertex

Arguments:
	[in]	localVertexIndex = int


Returns the tangent (or binormal) index for the specified vertex. This index refers to an element in the normal array returned by  MFnMesh::getTangents . These tangent or binormals are per-polygon per-vertex. See the  MFnMesh  description for more information on tangents and binormals.'''
        pass

    def getUVArea(self, uvSet, area): 
        '''getUVArea(self, uvSet, area)
Arguments:
	[out]	area = double
	[in]	uvSet = MString


This method gets the UV area of the face'''
        pass

    def getUVs(self, uvSet, uArray, vArray): 
        '''getUVs(self, uvSet, uArray, vArray)
Arguments:
	[out]	uArray = MFloatArray
	[out]	vArray = MFloatArray
	[in]	uvSet = MString


Return the all the texture coordinates for the vertices of this face (in local vertex order).'''
        pass

    def numColors(self, colorSetName, colorCount): 
        '''numColors(self, colorSetName, colorCount)
Arguments:
	[out]	colorCount = int
	[in]	colorSetName = MString


This method checks for the number of colors on vertices in this face.'''
        pass

    def getUVSetNames(self, setNames): 
        '''getUVSetNames(self, setNames)
Arguments:
	[out]	setNames = MStringArray


This method is used to find the UV set names mapped to the current face.'''
        pass

    def getTriangle(self, localTriIndex, space, points, vertexList): 
        '''getTriangle(self, localTriIndex, space, points, vertexList)
Arguments:
	[in]	localTriIndex = int
	[out]	points = MPointArray
	[out]	vertexList = MIntArray
	[in]	space = MSpace.Space


Get the vertices and vertex positions of the given triangle in the current face's triangulation.'''
        pass

    def zeroArea(self): 
        '''zeroArea(self) -> bool
Returns: Boolean value: true if the face has zero area, false otherwise.


This method checks if its a zero area face'''
        pass

    def hasValidTriangulation(self): 
        '''hasValidTriangulation(self) -> bool
Returns: Boolean value: true the face has a valid triangulation false otherwise.


This method checks if the face has a valid triangulation. If it doesn't, then the face was bad geometry: it may gave degenerate points or cross over itself.'''
        pass

    def getUV(self, vertex, uvSet, uvPoint): 
        '''getUV(self, vertex, uvSet, uvPoint)
Arguments:
	[in]	vertex = int
	[out]	uvPoint = float2
	[in]	uvSet = MString


Return the texture coordinate for the given vertex.'''
        pass

    def getColorIndices(self, colorSetName, colorIndices): 
        '''getColorIndices(self, colorSetName, colorIndices)
Arguments:
	[out]	colorIndices = MIntArray
	[in]	colorSetName = MString


This method returns the colorIndices for each vertex on the face.'''
        pass

    def setPoints(self, pointArray, space): 
        '''setPoints(self, pointArray, space)
Arguments:
	[in]	pointArray = MPointArray
	[in]	space = MSpace.Space


Sets new locations for vertices of the current polygon that the iterator is pointing to.'''
        pass

    def updateSurface(self): 
        '''updateSurface(self)

Signal that this polygonal surface has changed and needs to redraw itself.'''
        pass

    def reset(self, polyObject, component): 
        '''reset(self, polyObject, component)
Arguments:
	[in]	polyObject = MDagPath
	[in]	component = MObject


Reset the iterator with the given surface and component. If component is null then the iteration will be for all polygons in the given surface.'''
        pass

    def getPointAtUV(self, uvPoint, space, uvSet, tolerance, pt): 
        '''getPointAtUV(self, uvPoint, space, uvSet, tolerance, pt)
Arguments:
	[out]	pt = MPoint
	[in]	uvPoint = float2
	[in]	space = MSpace.Space
	[in]	uvSet = MString
	[in]	tolerance = float


Return the position of the point at the given UV value in the current polygon.'''
        pass

    def isConnectedToVertex(self, index): 
        '''isConnectedToVertex(self, index) -> bool
Returns: Boolean value: true if connected, false otherwise.

Arguments:
	[in]	index = int


This method determines whether the given vertex shares an edge with a vertex in the current face.'''
        pass

    def center(self, space): 
        '''center(self, space) -> MPoint
Returns: The center of the current polygon

Arguments:
	[in]	space = MSpace.Space


Return the position of the center of the current polygon.'''
        pass

    def getPoints(self, space, pointArray): 
        '''getPoints(self, space, pointArray)
Arguments:
	[out]	pointArray = MPointArray
	[in]	space = MSpace.Space


Retrieves the positions of the vertices on the current face/polygon that the iterator is pointing to. Vertex positions will be inserted into the given array and will be indexed using face-relative vertex IDs (ie. ordered from 0 to (vertexCount of the face) - 1), which should not be confused with the vertexIDs of each vertex in relation to the entire mesh object.'''
        pass

    def setPoint(self, point, index, space): 
        '''setPoint(self, point, index, space)
Arguments:
	[in]	point = MPoint
	[in]	index = int
	[in]	space = MSpace.Space


Set the vertex at the given index in the current polygon.'''
        pass

    def getNormal(self, index, space, normal): 
        '''getNormal(self, index, space, normal)
Arguments:
	[in]	index = int
	[out]	normal = MVector
	[in]	space = MSpace.Space


Returns the vertex-face normal for the vertex in the current polygon.'''
        pass

    def vertexIndex(self, index): 
        '''vertexIndex(self, index) -> int
Returns: The index in the polygon array of the given vertex

Arguments:
	[in]	index = int


Returns the object-relative index of the specified vertex of the current polygon. The index returned may be used to refer to an element in the vertex list returned by  MFnMesh::getPoints .'''
        pass

    def getConnectedVertices(self, vertices): 
        '''getConnectedVertices(self, vertices)
Arguments:
	[out]	vertices = MIntArray


This method gets the object-relative indices of the vertices surrounding the vertices of the current face, but does not include the vertices of the current face'''
        pass

    def isStarlike(self): 
        '''isStarlike(self) -> bool
Returns: Boolean value: true if the face is starlike, false otherwise.


This method checks if the face is starlike. That is, a line from the centre to any vertex lies entirely within the face.'''
        pass

    def getTriangles(self, space, points, vertexList): 
        '''getTriangles(self, space, points, vertexList)
Arguments:
	[out]	points = MPointArray
	[out]	vertexList = MIntArray
	[in]	space = MSpace.Space


Get the vertices and vertex positions of all the triangles in the current face's triangulation.'''
        pass

    def getColors(self, colorSetName, colors): 
        '''getColors(self, colorSetName, colors)
Arguments:
	[out]	colors = MColorArray
	[in]	colorSetName = MString


This method gets the color of the each vertex in the current face.'''
        pass

    def polygonVertexCount(self): 
        '''polygonVertexCount(self) -> int
Returns: The number of vertices for the current polygon


Return the number of vertices for the current polygon.'''
        pass

    def numConnectedFaces(self, faceCount): 
        '''numConnectedFaces(self, faceCount)
Arguments:
	[out]	faceCount = int


This method checks for the number of connected faces'''
        pass

class MItMeshVertex:
    '''Polygon vertex iterator. This class is the iterator for polygonal vertices.The iterator functions in two modes depending on whether a component is specified. When a component is not given or is NULL the iteration will be over all vertices for the polygon. When a component is given this iterator will iterate over the vertices specified in the component. When iterating over components a DAG path to the surface must also be supplied. '''
    def __init__(self):
        pass


    def onBoundary(self): 
        '''onBoundary(self) -> bool
Returns: Boolean value: true if contained, false otherwise.


This method determines whether the current vertex is on a Boundary'''
        pass

    def connectedToFace(self, index): 
        '''connectedToFace(self, index) -> bool

Arguments:
	[in]	index = int


This method determines whether the given face contains the current vertex'''
        pass

    def connectedToEdge(self, index): 
        '''connectedToEdge(self, index) -> bool

Arguments:
	[in]	index = int


This method determines whether the given edge contains the current vertex'''
        pass

    def getConnectedFaces(self, faces): 
        '''getConnectedFaces(self, faces)
Arguments:
	[out]	faces = MIntArray


This method gets the indices of the faces connected to the current vertex.'''
        pass

    def getNormal(self, faceIndex, space, vector): 
        '''getNormal(self, faceIndex, space, vector)
Arguments:
	[out]	vector = MVector
	[in]	faceIndex = int
	[in]	space = MSpace.Space


Return the normal of the current vertex in the specified face'''
        pass

    def setIndex(self, index, prevIndex): 
        '''setIndex(self, index, prevIndex)
Arguments:
	[in]	index = int
	[in]	prevIndex = int


This method sets the index of the current vertex to be accessed. The current vertex will no longer be in sync with any previous iteration.'''
        pass

    def getConnectedEdges(self, edges): 
        '''getConnectedEdges(self, edges)
Arguments:
	[out]	edges = MIntArray


This method gets the indices of the edges connected to the current vertex.'''
        pass

    def setUVs(self, uArray, vArray, faceIds, uvSet): 
        '''setUVs(self, uArray, vArray, faceIds, uvSet)
Arguments:
	[in]	uArray = MFloatArray
	[in]	vArray = MFloatArray
	[in]	faceIds = MIntArray
	[in]	uvSet = MString


Set the UV value for the specified faces at the current vertex. If the face is not already mapped, the value will not be set. If at least ne face was previously mapped, the method should succeed. If no faces were mapped, the method will fail.'''
        pass

    def getNormalIndices(self, normalIndices): 
        '''getNormalIndices(self, normalIndices)
Arguments:
	[out]	normalIndices = MIntArray


This method returns the normal indices of the face/vertex associated with the current vertex.'''
        pass

    def getNormals(self, space, normalArray): 
        '''getNormals(self, space, normalArray)
Arguments:
	[out]	normalArray = MVectorArray
	[in]	space = MSpace.Space


Return the normals of the current vertex for all faces'''
        pass

    def geomChanged(self): 
        '''geomChanged(self)

Reset the geom pointer in the  MItMeshVertex . If you're using  MFnMesh  to update Normals or Color per vertex while iterating, you must call geomChanged on the iteratior immediately after the  MFnMesh  call to make sure that your geometry is up to date. A crash may result if this method is not called. A similar approach must be taken for updating upstream vertex tweaks with an  MPlug . After the update, call this method.'''
        pass

    def numUVs(self, uvSet, uvCount): 
        '''numUVs(self, uvSet, uvCount)
Arguments:
	[out]	uvCount = int
	[in]	uvSet = MString


This method returns the number of unique UVs mapped on this vertex'''
        pass

    def index(self): 
        '''index(self) -> int
Returns: The index in the vertex list for the current vertex


Returns the index of the current vertex in the vertex list for this polygonal object. Polygonal objects contain a list of vertices. Faces and edges are specified as indicies from this list, in this way vertices can be shared amoung faces and edges.'''
        pass

    def getUVs(self, uvSet, uArray, vArray, faceIds): 
        '''getUVs(self, uvSet, uArray, vArray, faceIds)
Arguments:
	[out]	uArray = MFloatArray
	[out]	vArray = MFloatArray
	[out]	faceIds = MIntArray
	[in]	uvSet = MString


Get the UV values for all mapped faces at the current vertex. If at least one face was mapped the method will succeed.'''
        pass

    def next(self): 
        '''next(self)

Advance to the next vertex in the iteration.'''
        pass

    def getUVIndices(self, uvSet, uvIndices): 
        '''getUVIndices(self, uvSet, uvIndices)
Arguments:
	[out]	uvIndices = MIntArray
	[in]	uvSet = MString


This method returns the uv indices into the normal array see  MFnMesh::getUVs()  of the current vertex.'''
        pass

    def getOppositeVertex(self, edgeId, vertexId): 
        '''getOppositeVertex(self, edgeId, vertexId)
Arguments:
	[out]	vertexId = int
	[in]	edgeId = int


This gets the other vertex of the given edge'''
        pass

    def currentItem(self): 
        '''currentItem(self) -> MObject
Returns: The current vertex in the interation


Get the current vertex in the iteration as a component.'''
        pass

    def isDone(self): 
        '''isDone(self) -> bool
Returns: Boolean value: true if all vertices have been traversed, false otherwise.


Indicates if all of the vertices have been traversed yet.'''
        pass

    def count(self): 
        '''count(self) -> int
Returns: The number of vertices in the iteration


Return the number of vertices in the iteration.'''
        pass

    def getColor(self, colorSetName, color): 
        '''getColor(self, colorSetName, color)
Arguments:
	[out]	color = MColor
	[in]	colorSetName = MString


This method gets the average color of the vertex'''
        pass

    def getColorIndices(self, colorSetName, colorIndices): 
        '''getColorIndices(self, colorSetName, colorIndices)
Arguments:
	[out]	colorIndices = MIntArray
	[in]	colorSetName = MString


This method returns the colorIndices into the color array see  MFnMesh::getColors()  of the current vertex.'''
        pass

    def numConnectedEdges(self, edgeCount): 
        '''numConnectedEdges(self, edgeCount)
Arguments:
	[out]	edgeCount = int


This Method checks for the number of connected Edges on this vertex'''
        pass

    def translateBy(self, vector, space): 
        '''translateBy(self, vector, space)
Arguments:
	[in]	vector = MVector
	[in]	space = MSpace.Space


Translate the current vertex by the amount specified by the given vector.'''
        pass

    def getColors(self, colorSetName, colors): 
        '''getColors(self, colorSetName, colors)
Arguments:
	[out]	colors = MColorArray
	[in]	colorSetName = MString


This method gets the colors of the current vertex for each face it belongs to. If no colors are assigned to the vertex at all, the return values will be (-1 -1 -1 1). If some but not all of the vertex/face colors have been explicitly set, the ones that have not been set will be (0, 0, 0, 1).'''
        pass

    def getUV(self, faceId, uvSet, uvPoint): 
        '''getUV(self, faceId, uvSet, uvPoint)
Arguments:
	[in]	faceId = int
	[out]	uvPoint = float2
	[in]	uvSet = MString


Get the UV value for the give facen at the current vertex'''
        pass

    def setPosition(self, point, space): 
        '''setPosition(self, point, space)
Arguments:
	[in]	point = MPoint
	[in]	space = MSpace.Space


Set the position of the current vertex in the given space.'''
        pass

    def reset(self, polyObject, component): 
        '''reset(self, polyObject, component)
Arguments:
	[in]	polyObject = MDagPath
	[in]	component = MObject


Reset the iterator with the given polygon and component. If component is null then the iteration will be for all vertices in the given polygon.'''
        pass

    def updateSurface(self): 
        '''updateSurface(self)

Signal that this polygonal surface has changed and needs to redraw itself.'''
        pass

    def setUV(self, faceId, uvPoint, uvSet): 
        '''setUV(self, faceId, uvPoint, uvSet)
Arguments:
	[in]	faceId = int
	[in]	uvPoint = float2
	[in]	uvSet = MString


Set the UV value for the given face at the current vertex'''
        pass

    def hasColor(self, index): 
        '''hasColor(self, index) -> bool

Arguments:
	[in]	index = int


This method determines whether the given face has a color set for the current vertex.'''
        pass

    def getConnectedVertices(self, vertices): 
        '''getConnectedVertices(self, vertices)
Arguments:
	[out]	vertices = MIntArray


This method gets the indices of the vertices surrounding the current vertex'''
        pass

    def position(self, space): 
        '''position(self, space) -> MPoint
Returns: The position of the vertex in the specified space

Arguments:
	[in]	space = MSpace.Space


Return the position of the current vertex in the specified space. Object space ignores all transformations for the polygon, world space includes all such transformations.'''
        pass

    def numConnectedFaces(self, faceCount): 
        '''numConnectedFaces(self, faceCount)
Arguments:
	[out]	faceCount = int


This Method checks for the number of Connected Faces'''
        pass

class MItSelectionList:
    '''Iterate over the items in the selection list. Class for iterating over the items in an MSelection list. A filter can be specified so that only those items of interest on a selection list can be obtained.If a filter is specified then the children of DAG selection items will be searched if the selection item does not match the filter. For example, if  and a transform is selected then the underlying shape for the transform will be in the iteration if it is a nurbs curve. (of a simple traversal) (of a traversal to find all active cameras)'''
    def __init__(self):
        pass


    def reset(self): 
        '''reset(self)

Reset the iterator. If a filter has been specified then the current item will be the first selected item that matches the filter.'''
        pass

    def itemType(self): 
        '''itemType(self) -> MItSelectionList.selItemType
Returns: kDagSelectionItem - selection item is in the DAG 
kAnimSelectionItem - selection item is a keyset 
kDNselectionItem - selection item is a dependency node


Returns the current selection item type.'''
        pass

    def hasComponents(self): 
        '''hasComponents(self) -> bool
Returns: true the current selection item has components 
false the current selection item does not have components


Returns whether or not the current selection item has components.'''
        pass

    def getDagPath(self, dagPath): 
        '''getDagPath(self, dagPath)
Arguments:
	[out]	dagPath = MDagPath


This method retrieves the dag path of the current selection item.'''
        pass

    def next(self): 
        '''next(self)

Advance to the next item. If components are selected then advance to next component.'''
        pass

    def getStrings(self, array): 
        '''getStrings(self, array)
Arguments:
	[out]	array = MStringArray


Get the string representation of the current item in the selection list. It is possible that it will require more than one string to represent the item (the item may contain groups of CVs for example), so a string array is used to pass back the results.'''
        pass

    def kDNselectionItem(self):
        '''This is an enum of selItemType.
Description: dependency node
Value: 2'''
        pass

    def kAnimSelectionItem(self):
        '''This is an enum of selItemType.
Description: keyset
Value: 1'''
        pass

    def kDagSelectionItem(self):
        '''This is an enum of selItemType.
Description: DAG node or component.
Value: 0'''
        pass

    def kPlugSelectionItem(self):
        '''This is an enum of selItemType.
Description: 
Value: 3'''
        pass

    class selItemType:
        '''Non-functional class.  Values for this enum:
        kDNselectionItem
        kAnimSelectionItem
        kDagSelectionItem
        kPlugSelectionItem
'''
        def __init__(self):
            pass

    def getPlug(self, plug): 
        '''getPlug(self, plug)
Arguments:
	[out]	plug = MPlug


This method retrieves the plug of the current selection item.'''
        pass

    def setFilter(self, filter): 
        '''setFilter(self, filter)
Arguments:
	[in]	filter = MFn.Type


Apply a filter to the iteration. Selection items not matching the filter type will be excluded from the iteration.'''
        pass

    def isDone(self): 
        '''isDone(self) -> bool
Returns: true if there is nothing else to iterate over 
false if there are more items left to iterate over


Specifies whether or not there is anything more to iterator over.'''
        pass

    def getDependNode(self, depNode): 
        '''getDependNode(self, depNode)
Arguments:
	[out]	depNode = MObject


This method retrieves the dependency node of the current selection item'''
        pass

class MItSubdEdge:
    '''Subdiv edge iterator. This class is the iterator for subdiv edges. '''
    def __init__(self):
        pass


    def reset(self): 
        '''reset(self)

Reset the iterator to the first edge.'''
        pass

    def index(self): 
        '''index(self) -> MUint64
Returns: The index in the edge list for the current edge


Returns the index of the current edge in the edge list for this subdiv object.'''
        pass

    def isSharp(self): 
        '''isSharp(self) -> bool
Returns: boolean indicating whether the edge is sharp or not.


Returns true if the edge is sharp.'''
        pass

    def level(self): 
        '''level(self) -> int
Returns: The level.


Returns the level of the subdiv object.'''
        pass

    def isValid(self): 
        '''isValid(self) -> bool
Returns: bool Boolean to indicate whether the iterator is valid or not.


Checks if the iterator is valid.'''
        pass

    def setLevel(self, level): 
        '''setLevel(self, level)
Arguments:
	[in]	level = int


Sets the level of the subdiv object'''
        pass

    def next(self): 
        '''next(self)

Advance to the next edge in the iteration.'''
        pass

    def isBoundary(self): 
        '''isBoundary(self) -> bool
Returns: Boolean indicating whether the edge is boundary or not.


Checks if the edge is a boundary.'''
        pass

    def setSharpness(self, sharp): 
        '''setSharpness(self, sharp)
Arguments:
	[in]	sharp = bool


Marks the edge as sharp.'''
        pass

    def isDone(self): 
        '''isDone(self) -> bool
Returns: true All vertices have been traversed 
false There are more vertices in the iteration


Indicates if all of the edges have been traversed yet.'''
        pass

class MItSubdFace:
    '''Subdiv face iterator. This class is the iterator for subdiv faces. It will iterate over all of the surface's faces. '''
    def __init__(self):
        pass


    def reset(self): 
        '''reset(self)

Reset the iterator to the first face.'''
        pass

    def index(self): 
        '''index(self) -> MUint64
Returns: The index in the face list for the current face


Returns the index of the current face for this subdiv object.'''
        pass

    def level(self): 
        '''level(self) -> int
Returns: The level.


Returns the level of the subdiv object.'''
        pass

    def isValid(self): 
        '''isValid(self) -> bool
Returns: bool Boolean to indicate whether the iterator is valid or not.


Checks if the iterator is valid.'''
        pass

    def setLevel(self, level): 
        '''setLevel(self, level)
Arguments:
	[in]	level = int


Sets the level of the subdiv object'''
        pass

    def next(self): 
        '''next(self)

Advance to the next face in the iteration.'''
        pass

    def isDone(self): 
        '''isDone(self) -> bool
Returns: true All vertices have been traversed 
false There are more vertices in the iteration


Indicates if all of the faces have been traversed yet.'''
        pass

class MItSubdVertex:
    '''Subdiv vertex iterator. This class is the iterator for subdiv vertices. '''
    def __init__(self):
        pass


    def reset(self): 
        '''reset(self)

Reset the iterator to the first vertex.'''
        pass

    def index(self): 
        '''index(self) -> MUint64


Returns the index of the current vertex in the vertex list for this subdiv object.'''
        pass

    def level(self): 
        '''level(self) -> int


Returns the level of the subdiv object.'''
        pass

    def isValid(self): 
        '''isValid(self) -> bool


Checks if the iterator is valid.'''
        pass

    def setLevel(self, level): 
        '''setLevel(self, level)
Arguments:
	[in]	level = int


Sets the level of the subdiv object'''
        pass

    def next(self): 
        '''next(self)

Advance to the next vertex in the iteration.'''
        pass

    def isDone(self): 
        '''isDone(self) -> bool


Indicates if all of the vertices have been traversed yet.'''
        pass

class MItSurfaceCV:
    '''NURBS surface CV iterator. Iterator class for NURBS surface CVs. Translates the CVs for a surface in the X direction (world space).'''
    def __init__(self):
        pass


    def reset(self, surface, component, useURows): 
        '''reset(self, surface, component, useURows)
Arguments:
	[in]	surface = MDagPath
	[in]	component = MObject
	[in]	useURows = bool


Reset the iterator to iterate over the CVs of the given surface that are specified in the given component. If the component is NULL then the iteration will be over all CVs on the surface.'''
        pass

    def index(self): 
        '''index(self) -> int
Returns: The index for the current CV in the iteration


Get the index of the current CV as it appears in CV array for this surface.'''
        pass

    def getIndex(self, indexU, indexV): 
        '''getIndex(self, indexU, indexV)
Arguments:
	[out]	indexU = int
	[out]	indexV = int


Get the index of the current CV as it appears in CV array for this surface.'''
        pass

    def updateSurface(self): 
        '''updateSurface(self)

This method is used to signal the surface that it has been changed and needs to redraw itself.'''
        pass

    def hasHistoryOnCreate(self): 
        '''hasHistoryOnCreate(self) -> bool


This method determines if the shape was created with history.'''
        pass

    def isRowDone(self): 
        '''isRowDone(self) -> bool
Returns: Boolean value: true if the current row in the iteration is finished, false otherwise.


Returns  true  if the current row has no more CVs to iterate over. The row can be in the U or V direction depending on what value of  useURows  has been set in the constructor.'''
        pass

    def translateBy(self, space, vector): 
        '''translateBy(self, space, vector)
Arguments:
	[out]	vector = MVector
	[in]	space = MSpace.Space


Move the current CV in the iteration by the sepcified vector.'''
        pass

    def next(self): 
        '''next(self)

Advance to the next CV in the iteration. If the iterator is already at the last CV then this method has no effect. Use  isDone  to determine if the iterator is at the last CV.'''
        pass

    def nextRow(self): 
        '''nextRow(self)

Advance to the next row in the iteration. The row can be in the U or V direction depending on what value of  useURows  has been set in the constructor.'''
        pass

    def currentItem(self): 
        '''currentItem(self) -> MObject
Returns: The current CV in the interation


Get the current CV in the iteration as a component.'''
        pass

    def position(self, space): 
        '''position(self, space) -> MPoint
Returns: The position of the current CV in the iteration

Arguments:
	[in]	space = MSpace.Space


Returns the position of the current CV in the iteration in the specified space.'''
        pass

    def setPosition(self, space, point): 
        '''setPosition(self, space, point)
Arguments:
	[out]	point = MPoint
	[in]	space = MSpace.Space


Set the position of the current CV in the iteration to the specified point.'''
        pass

    def isDone(self): 
        '''isDone(self) -> bool
Returns: Boolean value: true if there are no more CVs to iterate on, false otherwise.


Returns  true  if the iteration is finished, i.e. there are no more CVs to iterate on.'''
        pass

class MLockMessage:
    '''Node and plug locking messages. Plug locking was implemented with Maya 1.0. Individual plugs can be locked so that their values cannot be changed. The locking state is held within the plug. The plug's locked state can be changed via the API with the method MPlug::setLocked(bool), or, in MEL, using the command "setAttr -l {on,off}".The ability to lock nodes was added with Maya 4.5. Node locking prevents renaming, reparenting, deletion, and other node-related changes. It also restricts the ability to change the state of any plug locks. The intent is that the user relies upon plug locking first, to lock the desired plugs they don't want to change, and then uses node locking to lock the node itself. Node locking can be set via MEL command, "lockNode", or via MFnDependencyNode::setLocked(bool)MLockMessage class allows the API user to register callbacks that control how Maya handles locks. The registered callbacks are invoked whenever a query to the lock state is involved. Therefore, the callback would be called even if the node was not locked.When a callback is invoked, the API user will be given a decision variable where they can place their decision. This decision variable is a boolean, and the boolean can take on the following values:You must use caution when using these routines. The flow of execution is interrupted when these callbacks are invoked. Therefore, you should make your decision in a timely maanner or a serious performance penalty will result. Also, you should NEVER try to alter the DG state while executing within callback. This includes quering/assigning a plug's value. You may, however, examine state information like the lock state of the plug/node. '''
    def __init__(self):
        pass


    def kCreateNodeInstance(self):
        '''This is an enum of LockDAGEvent.
Description: Lock query on an instance event.
Value: 5'''
        pass

    def kLastDAG(self):
        '''This is an enum of LockDAGEvent.
Description: Used for internal bounds checking.
Value: 8'''
        pass

    def kUnGroup(self):
        '''This is an enum of LockDAGEvent.
Description: Lock query on ungroup action.
Value: 2'''
        pass

    def kInvalidDAG(self):
        '''This is an enum of LockDAGEvent.
Description: Invalid DAG event received.
Value: 0'''
        pass

    def kCreateChildInstance(self):
        '''This is an enum of LockDAGEvent.
Description: Lock query on node whose children will be instanced.
Value: 6'''
        pass

    def kChildReorder(self):
        '''This is an enum of LockDAGEvent.
Description: Lock query on a child add action.
Value: 4'''
        pass

    def kReparent(self):
        '''This is an enum of LockDAGEvent.
Description: Lock query on reparent action.
Value: 3'''
        pass

    def kGroup(self):
        '''This is an enum of LockDAGEvent.
Description: Lock query on group action.
Value: 1'''
        pass

    def kCreateParentInstance(self):
        '''This is an enum of LockDAGEvent.
Description: Lock query on node whose parent will be instanced.
Value: 7'''
        pass

    class LockDAGEvent:
        '''Non-functional class.  Values for this enum:
        kCreateNodeInstance
        kLastDAG
        kUnGroup
        kInvalidDAG
        kCreateChildInstance
        kChildReorder
        kReparent
        kGroup
        kCreateParentInstance
'''
        def __init__(self):
            pass

    def kInvalidPlug(self):
        '''This is an enum of LockPlugEvent.
Description: An invalid plug event received.
Value: 0'''
        pass

    def kPlugAttrValChange(self):
        '''This is an enum of LockPlugEvent.
Description: Plug lock query on plug value change.
Value: 3'''
        pass

    def kPlugRemoveAttr(self):
        '''This is an enum of LockPlugEvent.
Description: Plug lock query on a remove attribute event.
Value: 4'''
        pass

    def kLastPlug(self):
        '''This is an enum of LockPlugEvent.
Description: Used for internal bounds checking.
Value: 8'''
        pass

    def kPlugConnect(self):
        '''This is an enum of LockPlugEvent.
Description: Plug lock query on a connect to a locked attribute.
Value: 6'''
        pass

    def kPlugUnlockAttr(self):
        '''This is an enum of LockPlugEvent.
Description: User is trying to unlock the plug.
Value: 2'''
        pass

    def kPlugRenameAttr(self):
        '''This is an enum of LockPlugEvent.
Description: Plug lock query on a rename attribute event.
Value: 5'''
        pass

    def kPlugDisconnect(self):
        '''This is an enum of LockPlugEvent.
Description: Plug lock query on a disconnect from a locked source attribute.
Value: 7'''
        pass

    def kPlugLockAttr(self):
        '''This is an enum of LockPlugEvent.
Description: User is trying to lock the plug.
Value: 1'''
        pass

    class LockPlugEvent:
        '''Non-functional class.  Values for this enum:
        kInvalidPlug
        kPlugAttrValChange
        kPlugRemoveAttr
        kLastPlug
        kPlugConnect
        kPlugUnlockAttr
        kPlugRenameAttr
        kPlugDisconnect
        kPlugLockAttr
'''
        def __init__(self):
            pass

    def setNodeLockDAGQueryCallback(self, dagPath, func, clientData): 
        '''setNodeLockDAGQueryCallback(self, dagPath, func, clientData) -> MCallbackId
Returns: A unique id for the callback.

Arguments:
	[in]	dagPath = MDagPath
	[in]	func = MLockMessage.MLockDagEventFunction
	[in]	clientData = void


This methods registers a callback that is invoked in any situation involving a locking condition on DAG level changes. When called, the API user can make a decision on how to handle the given locking situation. The programmer can either accept the default action, or they can deny the default action. The decision is returned through a decision variable which is passed to the callback function.'''
        pass

    def setNodeLockQueryCallback(self, node, func, clientData): 
        '''setNodeLockQueryCallback(self, node, func, clientData) -> MCallbackId
Returns: A unique id for the callback.

Arguments:
	[in]	node = MObject
	[in]	func = MLockMessage.MLockEventFunction
	[in]	clientData = void


This methods registers a callback that is invoked in any locking condition on node properties, e.g. name, lock status, etc. When called, the API user can make a decision on how to handle the given locking situation. The programmer can either accept the default action, or they can deny the default action. The decision is returned through a decision variable which is passed to the callback function.'''
        pass

    def setPlugLockQueryCallback(self, node, func, clientData): 
        '''setPlugLockQueryCallback(self, node, func, clientData) -> MCallbackId
Returns: A unique id for the callback.

Arguments:
	[in]	node = MObject
	[in]	func = MLockMessage.MLockPlugEventFunction
	[in]	clientData = void


This method registers a callback that is invoked in any locking condition on any plug of a given node, e.g. plug unlock, plug lock, connections, etc. When the callback is invoked, the API programmer can make a decision on how to handle the given locking situation. The programmer can either accept the default action, or they can deny the default action. The decision is returned through a decision variable which is passed to the callback function.'''
        pass

    def kAddAttr(self):
        '''This is an enum of LockEvent.
Description: Lock query on an add attribute event.
Value: 5'''
        pass

    def kRename(self):
        '''This is an enum of LockEvent.
Description: Lock query on a rename event.
Value: 1'''
        pass

    def kInvalid(self):
        '''This is an enum of LockEvent.
Description: Invalid node lock event received.
Value: 0'''
        pass

    def kDelete(self):
        '''This is an enum of LockEvent.
Description: Lock query on a delete event.
Value: 2'''
        pass

    def kUnlockAttr(self):
        '''This is an enum of LockEvent.
Description: Lock query on an unlock attribute event.
Value: 8'''
        pass

    def kRemoveAttr(self):
        '''This is an enum of LockEvent.
Description: Lock query on an remove attribute event.
Value: 6'''
        pass

    def kUnlockNode(self):
        '''This is an enum of LockEvent.
Description: Lock query on an unlock event.
Value: 4'''
        pass

    def kLockAttr(self):
        '''This is an enum of LockEvent.
Description: Lock query on a lock attribute event.
Value: 9'''
        pass

    def kLast(self):
        '''This is an enum of LockEvent.
Description: Used for internal bounds checking.
Value: 10'''
        pass

    def kRenameAttr(self):
        '''This is an enum of LockEvent.
Description: Lock query on an rename attribute event.
Value: 7'''
        pass

    def kLockNode(self):
        '''This is an enum of LockEvent.
Description: Lock query on a lock event.
Value: 3'''
        pass

    class LockEvent:
        '''Non-functional class.  Values for this enum:
        kAddAttr
        kRename
        kInvalid
        kDelete
        kUnlockAttr
        kRemoveAttr
        kUnlockNode
        kLockAttr
        kLast
        kRenameAttr
        kLockNode
'''
        def __init__(self):
            pass

class MMatrix:
    '''A matrix math class for 4x4 matrices of doubles. This class provides access to Maya's internal matrix math library allowing matrices to be handled easily, and in a manner compatible with internal Maya data structures.All methods that query the matrix are threadsafe, all methods that modify the matrix are not threadsafe. '''
    def __init__(self):
        pass


    def setToIdentity(self): 
        '''setToIdentity(self) -> MMatrix


Set this instance to the 4x4 identity matrix. 
  Reprocessed example  
 Examples: 
 
   
 cgfxShaderNode.cpp , and  GLSLShaderNode.cpp . 
 
'''
        pass

    def inverse(self): 
        '''inverse(self) -> MMatrix


Compute and return the inverse of this instance.'''
        pass

    def setToProduct(self, left, right): 
        '''setToProduct(self, left, right) -> MMatrix

Arguments:
	[in]	left = MMatrix
	[in]	right = MMatrix


Set this instance to the inner product of the two argument matrices.'''
        pass

    def homogenize(self): 
        '''homogenize(self) -> MMatrix


Compute and return a homogenized version of this instance.'''
        pass

    def __getitem__(self, row): 
        '''__getitem__(self, row) -> double*
Returns: double array containing the values of the specified row 

Arguments:
	[in]	row = int


Index operator. Returns an entire row of the matrix as an array of doubles.'''
        pass

    def get(self, dest): 
        '''get(self, dest)
Arguments:
	[out]	dest = float4


Fill a 4x4 matrix of floats with the elements from the instance.'''
        pass

    def __rmult__(self, factor): 
        '''__rmult__(self, factor) -> MMatrix

Arguments:
	[in]	factor = double

'''
        pass

    def adjoint(self): 
        '''adjoint(self) -> MMatrix


Compute and return the adjoint of this instance.'''
        pass

    def det4x4(self): 
        '''det4x4(self) -> double


Compute and return the determinant of this instance'''
        pass

    def transpose(self): 
        '''transpose(self) -> MMatrix


Compute and return the transpose of this instance.'''
        pass

    def isEquivalent(self, other, tolerance): 
        '''isEquivalent(self, other, tolerance) -> bool
Returns: true if the matrices are equivalent and false otherwise 

Arguments:
	[in]	other = MMatrix
	[in]	tolerance = double


Determine if the given matrix is equivalent to this instance within the specified tolerance.'''
        pass

    def isSingular(self): 
        '''isSingular(self) -> bool


Determines if the given matrix is singular.'''
        pass

    def __radd__(self, right): 
        '''__radd__(self, right) -> MMatrix

Arguments:
	[in]	right = MMatrix

'''
        pass

    def det3x3(self): 
        '''det3x3(self) -> double


Compute and return the determinant of the upper left 3x3 submatrix of this instance'''
        pass

    def __rsub__(self, right): 
        '''__rsub__(self, right) -> MMatrix

Arguments:
	[in]	right = MMatrix

'''
        pass

    def __mul__(self, factor): 
        '''__mul__(self, factor) -> MMatrix

Arguments:
	[in]	factor = double

'''
        pass

    def __add__(self, right): 
        '''__add__(self, right) -> MMatrix

Arguments:
	[in]	right = MMatrix

'''
        pass

    def __sub__(self, right): 
        '''__sub__(self, right) -> MMatrix

Arguments:
	[in]	right = MMatrix

'''
        pass

    def __eq__(self, other): 
        '''__eq__(self, other) -> bool

Arguments:
	[in]	other = MMatrix

'''
        pass

    def __neq__(self, other): 
        '''__neq__(self, other) -> bool

Arguments:
	[in]	other = MMatrix

'''
        pass

class MMeshIntersector:
    '''Mesh intersector. The MMeshIntersector class contains methods for efficiently finding the closest point to a mesh. An octree algorithm is used to find the closest point.The create() method builds the internal data required for the algorithm. As a result, calls to it should be minimized as it is a heavy operation.This class allows multiple threads to evaluate closest points simultaneously as the method getClosestPoint is threadsafe. '''
    def __init__(self):
        pass


    def isCreated(self): 
        '''isCreated(self) -> bool

'''
        pass

    def create(self, meshObject, matrix): 
        '''create(self, meshObject, matrix)
Arguments:
	[in]	meshObject = MObject
	[in]	matrix = MMatrix


This method creates the data required by the intersector. It is a heavy operation that should be called only when necessary.'''
        pass

    def getClosestPoint(self, point, maxDistance, meshPoint): 
        '''getClosestPoint(self, point, maxDistance, meshPoint)
Arguments:
	[in]	point = MPoint
	[out]	meshPoint = MPointOnMesh
	[in]	maxDistance = double


This method finds the closest point. Information is returned in the meshPoint object.'''
        pass

class MMeshSmoothOptions:
    '''Options for control of smooth mesh generation. The MMeshSmoothOptions class encapsulates settings that control the generation of smoothed version of a mesh. Meant for use with MFnMesh::generateSmoothMesh(). '''
    def __init__(self):
        pass


    def divisions(self): 
        '''divisions(self) -> int
Returns: The smoothing level


Retrieves the level of smoothing these options specify to perform on the mesh.'''
        pass

    def setPropEdgeHardness(self, propEdgeHardness): 
        '''setPropEdgeHardness(self, propEdgeHardness)
Arguments:
	[in]	propEdgeHardness = bool


Sets whether or not these options specify that smooth mesh edges which are a result of edges from the base cage will share the hardness value'''
        pass

    def setDivisions(self, numDivisions): 
        '''setDivisions(self, numDivisions)
Arguments:
	[in]	numDivisions = int


Sets the number of divisions stored in this options object.'''
        pass

    def setKeepHardEdge(self, keepHardEdge): 
        '''setKeepHardEdge(self, keepHardEdge)
Arguments:
	[in]	keepHardEdge = bool


Sets whether or not these options specify that hard edges will not be smoothed'''
        pass

    def keepHardEdge(self): 
        '''keepHardEdge(self) -> bool
Returns: True if hard edges will not be smoothed


Retrieves whether or not these options specify that hard edges will not be smoothed'''
        pass

    def smoothness(self): 
        '''smoothness(self) -> float
Returns: The smoothness parameter


Retrieves the smoothness parameter for this set of smooth options which has range [0,1] where 1 smooths the faces as much as possible'''
        pass

    def setKeepBorderEdge(self, keepBorderEdge): 
        '''setKeepBorderEdge(self, keepBorderEdge)
Arguments:
	[in]	keepBorderEdge = bool


Sets whether or not these options specify that border edges will not be smoothed'''
        pass

    def setSmoothness(self, smoothness): 
        '''setSmoothness(self, smoothness)
Arguments:
	[in]	smoothness = float


Sets the the smoothness parameter for this set of smooth options which has range [0,1] where 1 smooths the faces as much as possible'''
        pass

    def keepBorderEdge(self): 
        '''keepBorderEdge(self) -> bool
Returns: True if border edges will not be smoothed


Retrieves whether or not these options specify that border edges will not be smoothed'''
        pass

    def setSmoothUVs(self, smoothUVs): 
        '''setSmoothUVs(self, smoothUVs)
Arguments:
	[in]	smoothUVs = bool


Sets whether or not these options specify to smooth UVs as well as geometry.'''
        pass

    def propEdgeHardness(self): 
        '''propEdgeHardness(self) -> bool
Returns: True if smooth edges share hardness with the base cage


Retrieves whether or not these options specify that the smooth mesh edges which are a result of edges from the base cage will share the same hardness value.'''
        pass

    def smoothUVs(self): 
        '''smoothUVs(self) -> bool
Returns: True if UVs are set to be smoothed


Retrieves whether or not these options specify to smooth UVs as well as geometry.'''
        pass

class MMessage:
    '''Message base class. This is the base class for message callbacks. This base class allows the user to remove a message callback. To register a callback, the user must use the addCallback methods in the message classes which inherit from this base class.When a callback is added a number or id is returned. This id is used to keep track of the callback and is necessary for removing it. A callback id with the value 'NULL' represents an invalid callback. Use the removeCallback member function of this class for removing a callback.It is the user's responsibility to keep track of the callback id's and remove all callbacks for a plug-in when it is unloaded. '''
    def __init__(self):
        pass


    def setRegisteringCallableScript(self): 
        '''setRegisteringCallableScript(self)
'''
        pass

    def registeringCallableScript(self): 
        '''registeringCallableScript(self) -> bool

'''
        pass

    def currentCallbackId(self): 
        '''currentCallbackId(self) -> MCallbackId
Returns: Callback ID of currently executing callback


Return the callback ID of the currently executing callback. If called outside of a callback, an invalid MCallbackId and failed status will be returned.'''
        pass

    def nodeCallbacks(self, node, ids): 
        '''nodeCallbacks(self, node, ids)
Arguments:
	[in]	node = MObject
	[out]	ids = MCallbackIdArray


Returns a list of callback IDs associated registered to a given node.'''
        pass

    def removeCallbacks(self, idList): 
        '''removeCallbacks(self, idList)
Arguments:
	[in]	idList = MCallbackIdArray


Remove all of the specified callbacks from maya.'''
        pass

    def removeCallback(self, id): 
        '''removeCallback(self, id)
Arguments:
	[in]	id = MCallbackId


Remove the specified callback from maya.'''
        pass

class MModelMessage:
    '''Scene messages. This class is used to register callbacks for model related messages.The addCallback method registers a function that will be executed whenever the specified message occurs. An id is returned and is used to remove the callback.To remove a callback use MMessage::removeCallback. All callbacks that are registered by a plug-in must be removed by that plug-in when it is unloaded. Failure to do so will result in a fatal error. '''
    def __init__(self):
        pass


    def addNodeAddedToModelCallback(self, dagNode, func, clientData): 
        '''addNodeAddedToModelCallback(self, dagNode, func, clientData) -> MCallbackId

Arguments:
	[in]	dagNode = MObject
	[in]	func = MMessage.MNodeFunction
	[in]	clientData = void


Node added to model message. 
'''
        pass

    def addAfterDuplicateCallback(self, func, clientData): 
        '''addAfterDuplicateCallback(self, func, clientData) -> MCallbackId

Arguments:
	[in]	func = MMessage.MBasicFunction
	[in]	clientData = void


After duplicate callback. 
'''
        pass

    def addBeforeDuplicateCallback(self, func, clientData): 
        '''addBeforeDuplicateCallback(self, func, clientData) -> MCallbackId

Arguments:
	[in]	func = MMessage.MBasicFunction
	[in]	clientData = void


Before duplicate callback. 
'''
        pass

    def addNodeRemovedFromModelCallback(self, dagNode, func, clientData): 
        '''addNodeRemovedFromModelCallback(self, dagNode, func, clientData) -> MCallbackId

Arguments:
	[in]	dagNode = MObject
	[in]	func = MMessage.MNodeFunction
	[in]	clientData = void


Node removed from model message. 
'''
        pass

    def kActiveListModified(self):
        '''This is an enum of Message.
Description: active selection changes
Value: 0'''
        pass

    class Message:
        '''Non-functional class.  Values for this enum:
        kActiveListModified
'''
        def __init__(self):
            pass

    def addCallback(self, msg, func, clientData): 
        '''addCallback(self, msg, func, clientData) -> MCallbackId

Arguments:
	[in]	msg = MModelMessage.Message
	[in]	func = MMessage.MBasicFunction
	[in]	clientData = void


Adds a new callback for the specified model message.'''
        pass

class MNodeMessage:
    '''Dependency node messages. This class is used to register callbacks for dependency node messages of specific dependency nodes.There are 4 add callback methods which will add callbacks for the following messagesThe first parameter passed to each of the add callback methods is the depenency node that will trigger the callback.Callbacks that are registered for attribute changed/addedOrRemoved messages will be passed an AttributeMessage value as a parameter. This value indicates the type of attribute message that has occurred. See the AttributeMessage enum for all available messages.Each method returns an id which is used to remove the callback.To remove a callback use MMessage::removeCallback. All callbacks that are registered by a plug-in must be removed by that plug-in when it is unloaded. Failure to do so will result in a fatal error. '''
    def __init__(self):
        pass


    def addNodeDestroyedCallback(self, node, func, clientData): 
        '''addNodeDestroyedCallback(self, node, func, clientData) -> MCallbackId

Arguments:
	[in]	node = MObject
	[in]	func = MMessage.MBasicFunction
	[in]	clientData = void


NodeDestroyed callback. 
'''
        pass

    def kKeyChangeInvalid(self):
        '''This is an enum of KeyableChangeMsg.
Description: 
Value: 0'''
        pass

    def kMakeUnkeyable(self):
        '''This is an enum of KeyableChangeMsg.
Description: 
Value: 2'''
        pass

    def kKeyChangeLast(self):
        '''This is an enum of KeyableChangeMsg.
Description: 
Value: 3'''
        pass

    def kMakeKeyable(self):
        '''This is an enum of KeyableChangeMsg.
Description: 
Value: 1'''
        pass

    class KeyableChangeMsg:
        '''Non-functional class.  Values for this enum:
        kKeyChangeInvalid
        kMakeUnkeyable
        kKeyChangeLast
        kMakeKeyable
'''
        def __init__(self):
            pass

    def addNodePreRemovalCallback(self, node, func, clientData): 
        '''addNodePreRemovalCallback(self, node, func, clientData) -> MCallbackId

Arguments:
	[in]	node = MObject
	[in]	func = MMessage.MNodeFunction
	[in]	clientData = void


Registers a callback which will get called before a node is deleted. This callback is called before connections on the node are removed. Unlike the aboutToDelete callback, this callback will be invoked whenever the node is deleted, even during a redo.'''
        pass

    def kAttributeArrayAdded(self):
        '''This is an enum of AttributeMessage.
Description: an array attribute has been added to this node
Value: 4096'''
        pass

    def kAttributeRenamed(self):
        '''This is an enum of AttributeMessage.
Description: an attribute of this node has been renamed
Value: 256'''
        pass

    def kAttributeArrayRemoved(self):
        '''This is an enum of AttributeMessage.
Description: an array attribute has been removed from this node
Value: 8192'''
        pass

    def kConnectionBroken(self):
        '''This is an enum of AttributeMessage.
Description: a connection has been broken for an attribute of this node
Value: 2'''
        pass

    def kLast(self):
        '''This is an enum of AttributeMessage.
Description: last value of the enum
Value: 32768'''
        pass

    def kOtherPlugSet(self):
        '''This is an enum of AttributeMessage.
Description: the otherPlug data has been set
Value: 16384'''
        pass

    def kAttributeRemoved(self):
        '''This is an enum of AttributeMessage.
Description: an attribute has been removed from this node
Value: 128'''
        pass

    def kAttributeKeyable(self):
        '''This is an enum of AttributeMessage.
Description: an attribute of this node has been marked keyable
Value: 512'''
        pass

    def kAttributeUnlocked(self):
        '''This is an enum of AttributeMessage.
Description: an attribute of this node has been unlocked
Value: 32'''
        pass

    def kAttributeUnkeyable(self):
        '''This is an enum of AttributeMessage.
Description: an attribute of this node has been marked unkeyable
Value: 1024'''
        pass

    def kAttributeLocked(self):
        '''This is an enum of AttributeMessage.
Description: an attribute of this node has been locked
Value: 16'''
        pass

    def kIncomingDirection(self):
        '''This is an enum of AttributeMessage.
Description: the connection was coming into the node
Value: 2048'''
        pass

    def kAttributeAdded(self):
        '''This is an enum of AttributeMessage.
Description: an attribute has been added to this node
Value: 64'''
        pass

    def kAttributeEval(self):
        '''This is an enum of AttributeMessage.
Description: an attribute of this node has been evaluated
Value: 4'''
        pass

    def kAttributeSet(self):
        '''This is an enum of AttributeMessage.
Description: an attribute value of this node has been set
Value: 8'''
        pass

    def kConnectionMade(self):
        '''This is an enum of AttributeMessage.
Description: a connection has been made to an attribute of this node
Value: 1'''
        pass

    class AttributeMessage:
        '''Non-functional class.  Values for this enum:
        kAttributeArrayAdded
        kAttributeRenamed
        kAttributeArrayRemoved
        kConnectionBroken
        kLast
        kOtherPlugSet
        kAttributeRemoved
        kAttributeKeyable
        kAttributeUnlocked
        kAttributeUnkeyable
        kAttributeLocked
        kIncomingDirection
        kAttributeAdded
        kAttributeEval
        kAttributeSet
        kConnectionMade
'''
        def __init__(self):
            pass

    def addKeyableChangeOverride(self, plug, func, clientData): 
        '''addKeyableChangeOverride(self, plug, func, clientData) -> MCallbackId

Arguments:
	[in]	plug = MPlug
	[in]	func = MNodeMessage.MKeyableFunction
	[in]	clientData = void


Attribute keyable state change override. 
'''
        pass

    def addAttributeAddedOrRemovedCallback(self, node, func, clientData): 
        '''addAttributeAddedOrRemovedCallback(self, node, func, clientData) -> MCallbackId

Arguments:
	[in]	node = MObject
	[in]	func = MNodeMessage.MAttrPlugFunction
	[in]	clientData = void


Registers callbacks for attribute add/removed messages. This is a more specific version of addAttributeChanged as only attribute added and attribute removed messages will trigger the callback.'''
        pass

    def addNodeDirtyPlugCallback(self, node, func, clientData): 
        '''addNodeDirtyPlugCallback(self, node, func, clientData) -> MCallbackId

Arguments:
	[in]	node = MObject
	[in]	func = MMessage.MNodePlugFunction
	[in]	clientData = void


Registers a callback for node dirty messages. This callback provides the plug on the node that was dirtied. Only provides dirty information on input plugs.'''
        pass

    def addAttributeChangedCallback(self, node, func, clientData): 
        '''addAttributeChangedCallback(self, node, func, clientData) -> MCallbackId

Arguments:
	[in]	node = MObject
	[in]	func = MNodeMessage.MAttr2PlugFunction
	[in]	clientData = void


This method registers a callback for attribute changed messages. See the AttributeChanged enum for a list of all possible messages that will trigger the callback.'''
        pass

class MNurbsIntersector:
    '''Nurbs intersector. The MNurbsIntersector class contains methods for efficiently finding the closest point to a NURBS surface. A tree-based algorithm is used to find the closest point.The create() method builds the internal data required for the algorithm. As a result, calls to it should be minimized as it is a heavy operation. If the NURBS surface or matrix changes, you will need to recreate the tree based data to correspond, again using the create() method.This class is not threadsafe. '''
    def __init__(self):
        pass


    def isCreated(self): 
        '''isCreated(self) -> bool

'''
        pass

    def create(self, nurbsObject, matrix): 
        '''create(self, nurbsObject, matrix)
Arguments:
	[in]	nurbsObject = MObject
	[in]	matrix = MMatrix


This method creates the data required by the intersector. It is a heavy operation that should be called only when necessary, such as when the underlying NURBS surface or the matrix changes.'''
        pass

    def getIntersect(self, rayStartingPoint, alongThisDirection, tolerance, u, v, pntOfIntersection): 
        '''getIntersect(self, rayStartingPoint, alongThisDirection, tolerance, u, v, pntOfIntersection)
Arguments:
	[in]	rayStartingPoint = MPoint
	[in]	alongThisDirection = MVector
	[out]	u = double
	[out]	v = double
	[out]	pntOfIntersection = MPoint
	[in]	tolerance = double


This method finds the first point of intersection of the NURBS surface with a ray (a vector at a point). The point is returned in the pntOfIntersection object, and the U and V parameters of the point are returned in the u and v variables respectively.'''
        pass

    def getClosestPoint(self, point, maxDistance, nurbsPoint): 
        '''getClosestPoint(self, point, maxDistance, nurbsPoint)
Arguments:
	[in]	point = MPoint
	[out]	nurbsPoint = MPointOnNurbs
	[in]	maxDistance = double


This method finds the closest point. Information is returned in the nurbsPoint object.'''
        pass

    def getIntersects(self, rayStartingPoint, alongThisDirection, uArray, vArray, tolerance, points): 
        '''getIntersects(self, rayStartingPoint, alongThisDirection, uArray, vArray, tolerance, points)
Arguments:
	[in]	rayStartingPoint = MPoint
	[in]	alongThisDirection = MVector
	[in]	uArray = MDoubleArray
	[in]	vArray = MDoubleArray
	[out]	points = MPointArray
	[in]	tolerance = double


This method finds all the points of intersection of the NURBS surface with a ray (a vector at a point). The points are returned in the points object, and the U and V parameters of the points are returned in the uArray and vArray objects respectively.'''
        pass

class MObject:
    '''Generic Class for Accessing Internal Maya ObjectsDetermine the exact type (MFn::Type) of an MObject within Maya.Determine if an Object exists.Determine if an Object is compatible with a specific Function Set.MObject is the generic class for accessing all Maya internal modelling, animation and rendering Objects, collectively referred to as Model Objects, through the API. This includes all Dependency Graph (DG) Nodes, of which Directed Acyclic Graph (DAG) Nodes are a subset.Each instance of an MObject represents a specific Node or Attribute on a Node in the DG. Under the C++ class scheme MObjects simply have type MObject with no base or derived hierarchy. However, MObjects may be many different types of Model objects, from Attributes to transforms, including components of geometry such as Control Vertices (CV), faces, edges and vertices. This allows many different types of objects to be moved accessed through the API without undue concern on the part of plug-in developers for the type of object being manipulated.Since it is impractical to provide every applicable method in MObjects, the methods applicable to Maya Objects are encapsulated in Function Sets. Function Sets can be attached to compatible MObjects to provide an external interface to methods appropriate to that MObject.The link between an MObject and the role it performs as a Maya Model object, as well as the compatibility between MObjects and Function Sets is managed by the API Run-Time Type Identification (RTTI) system. The two key concepts of this system are the Maya Object type and the Function Set type (both in MFn::Type). All MObjects have one and only one Maya Object type. All Function Sets have one and only one Function Set type. MObjects may, however, be compatible with many types of Function Sets. This compatibility follows the class hierarchy of the Function Sets. Thus an MObject with Maya Object type MFn::kNurbsSurface would be compatible with MFnNurbsSurface, MFnDagNode, MFnDependencyNode, MFnNamedObject and MFnBase.Use the apiType() method to determine the type (MFn::Type) of the Maya Model Object.Use hasFn() to determine if the Object is comaptible with a given Function Set.Use isNull() to determine if the internal Maya Object exists. '''
    def __init__(self):
        pass


    kNullObj = ''
    '''Null Object for use as default argument. '''

    def hasFn(self, fs): 
        '''hasFn(self, fs) -> bool
Returns: true Is compatible 
false Is not compatible 

Arguments:
	[in]	fs = MFn.Type


Determines the whether or not the internal Object is compatible with the given Function Type.'''
        pass

    def apiTypeStr(self): 
        '''apiTypeStr(self) -> char*


Returns a string that gives the object's type is a readable form. This is useful for debugging when type of an object needs to be printed.'''
        pass

    def apiType(self): 
        '''apiType(self) -> MFn.Type


Determines the exact type of the Maya internal Object.'''
        pass

    def isNull(self): 
        '''isNull(self) -> bool


Determines the whether or not an internal Object exists.'''
        pass

    def __eq__(self, other): 
        '''__eq__(self, other) -> bool

Arguments:
	[in]	other = MObject

'''
        pass

    def __neq__(self, other): 
        '''__neq__(self, other) -> bool

Arguments:
	[in]	other = MObject

'''
        pass

class MObjectArray:
    '''Array of MObjects data type. This class implements an array of MObjects. Common convenience functions are available, and the implementation is compatible with the internal Maya implementation so that it can be passed efficiently between plugins and internal maya data structures. '''
    def __init__(self):
        pass


    def insert(self, element, index): 
        '''insert(self, element, index)
Arguments:
	[in]	element = MObject
	[in]	index = int


Inserts a new value into the array at the given index. The initial element at that index, and all following elements, are shifted towards the last. If the array cannot be expanded in size by 1 element, then the insert will fail and the existing array will remain unchanged.'''
        pass

    def set(self, element, index): 
        '''set(self, element, index)
Arguments:
	[in]	element = MObject
	[in]	index = int


Sets the value of the indicated element to the indicated  MObject  value.'''
        pass

    def clear(self): 
        '''clear(self)

Clear the contents of the array. After this operation the length method will return 0. This does not change the amount of memory allocated to the array, only the number of valid elements in it.'''
        pass

    def sizeIncrement(self): 
        '''sizeIncrement(self) -> int


Return the size by which the array will be expanded whenever expansion is necessary.'''
        pass

    def remove(self, index): 
        '''remove(self, index)
Arguments:
	[in]	index = int


Remove the array element at the given index. All array elements following the removed element are shifted toward the first element.'''
        pass

    def length(self): 
        '''length(self) -> int


Returns the number of elements in the instance.'''
        pass

    def setSizeIncrement(self, newIncrement): 
        '''setSizeIncrement(self, newIncrement)
Arguments:
	[in]	newIncrement = int


Set the size by which the array will be expanded whenever expansion is necessary.'''
        pass

    def MObject(self, index): 
        '''MObject(self, index) -> const
Returns: A reference to the indicated element 

Arguments:
	[in]	index = int


Index operator. Returns the value of the element at the given index. No range checking is done - valid indices are 0 to  length() -1.'''
        pass

    def setLength(self, length): 
        '''setLength(self, length)
Arguments:
	[in]	length = int


Set the length of the array. This will grow and shrink the array as desired. Elements that are grown have uninitialized values, while those which are shrunk will lose the data contained in the deleted elements (ie. it will release the memory).'''
        pass

    def append(self, element): 
        '''append(self, element)
Arguments:
	[in]	element = MObject


Adds a new element to the end of the array. If the array cannot be expanded in size by 1 element, then the append will fail and the existing array will remain unchanged.'''
        pass

class MObjectHandle:
    '''Generic Class for validating MObjects. MObjectHandle is a wrapper class for the MObject class. An MObjectHandle will provide a user with added information on the validity of an MObject. Each MObjectHandle that is created registers an entry into a table to maintain state tracking of the MObject that the handle was created for. This will help users track when an MObject is invalid and should be re-retrieved. '''
    def __init__(self):
        pass


    def isAlive(self): 
        '''isAlive(self) -> bool


Returns the live state of the associated  MObject . An object can still be 'alive' but not 'valid' (eg. a deleted object that resides in the undo queue).'''
        pass

    def isValid(self): 
        '''isValid(self) -> bool


Returns the validity of the associated  MObject .'''
        pass

    def object(self): 
        '''object(self) -> MObject


Returns the  MObject  associated with this handle. The returned  MObject  will be  MObject::kNullObj  if the object is invalid.'''
        pass

    def hashCode(self): 
        '''hashCode(self) -> int


Returns a hash code for the internal Maya object referenced by the  MObject  within this  MObjectHandle . If the  MObject  is null or no longer alive then 0 will be returned, otherwise the hash code is guaranteed to be non-zero.'''
        pass

    def MObject(self): 
        '''MObject(self) -> const


Returns the  MObject  associated with this handle. This provides read-only access to the  MObject  that  MObjectHandle  holds onto. This method will always return the object that belongs to  MObjectHandle  regardless of its validity. API users should use caution when using  MObject  data when it is not valid, and should never use the data when  MObjectHandle  indicates that the  MObject  is NOT alive.'''
        pass

    def __eq__(self, handle): 
        '''__eq__(self, handle) -> bool
Returns: true if the MObjectHandles are the same, false otherwise. 

Arguments:
	[in]	handle = MObjectHandle


Returns true if the  MObjectHandle  handles the same  MObject  as this  MObjectHandle .'''
        pass

    def __neq__(self, handle): 
        '''__neq__(self, handle) -> bool
Returns: true MObjectHandles are not the same, false otherwise. 

Arguments:
	[in]	handle = MObjectHandle


Returns true if the  MObjectHandle  does not handle the same  MObject  as this  MObjectHandle .'''
        pass

class MObjectSetMessage:
    '''Object Set Messages. This class is used to register callbacks for object set messages received by specific sets.There is 1 add callback method which will add callbacks for the following messageThe first parameter passed to each of the add callback methods is the object set depenency node that will trigger the callback. The second parameter specifies the callback function and the optional third parameter specifies the callback argument.Each method returns an id which is used to remove the callback.To remove a callback use MMessage::removeCallback(). All callbacks that are registered by a plug-in must be removed by that plug-in when it is unloaded. Failure to do so will result in a fatal error. '''
    def __init__(self):
        pass


    def addSetMembersModifiedCallback(self, node, func, clientData): 
        '''addSetMembersModifiedCallback(self, node, func, clientData) -> MCallbackId

Arguments:
	[in]	node = MObject
	[in]	func = MMessage.MNodeFunction
	[in]	clientData = void


Registers callbacks for set modified messages.'''
        pass

class MPlane:
    '''A plane equation. This class describes a mathematical plane. '''
    def __init__(self):
        pass


    def distance(self, point): 
        '''distance(self, point) -> double
Returns: The distance from the specified point to the plane. 

Arguments:
	[in]	point = MVector


Returns the unsigned distance from the plane to the specified point.'''
        pass

    def directedDistance(self, point): 
        '''directedDistance(self, point) -> double
Returns: The distance from the specified point to the plane. 

Arguments:
	[in]	point = MVector


Returns the signed distance from the plane to the specified point.'''
        pass

    def setPlane(self, n, d): 
        '''setPlane(self, n, d)
Arguments:
	[in]	n = MVector
	[in]	d = double


Set the equation of the plane from a normal and offset.'''
        pass

    def normal(self): 
        '''normal(self) -> MVector


Returns the normal of the plane.'''
        pass

class MPlug:
    '''Create and Access dependency node plugs. MPlug provides methods for creating plugs, and accessing the plugs' dependency node and attributes.A plug is a point on a dependency node where a particular attribute can be connected. In simple cases the plug and attribute are equivalent. When you have array attributes, however, the plug is more specific in that it indicates which of the array elements is to be connected.There are two main types of plugs: networked plugs and non-networked plugs. Non-networked plugs can be considered user plugs as they are created by users and belong to users. Networked plugs can be considered dependency node plugs as they are part of the dependency graph and can only be referenced by users.In every dependency node there is a network or "tree" of plugs indicating connections that have been made to attributes of the node. The plugs in this tree are known as  plugs as they belong to the dependency node's network. plugs are plugs that you can create in order to establish a new connection to an attribute, or to get or set a value on an attribute. When a connection is made using these plugs, a networked version of the plug is created and added to the dependency nodes network.A  plug cannot be explicitly created. They are created when a connection is established for some attribute of the node. Since the allocation of networked plugs is managed exclusively by Maya, a plugin should never reference a networked plug after changes are made to the DG. Instead, use a non-networked version of the plug, or get a new reference to the networked plug.All a  plug knows is how to uniquely describe the attribute that it references, in fact the purpose of a non-networked plug is to specify, without ambiguity, an attribute of a dependency node. A non-networked plug contains an array of array indices that plot the path from the root plug to this plug.For simple attributes the plug and attribute are equivalent. Compound attributes are also unambiguous. A plug that refers to an array attribute, however, is more complex as it can refer to the  or an  in the array.Several methods are provided for navigating the plug tree. The  method can be used to retrieve the  of a . The  and  methods can be used to retrieve the element plugs of an array plug. The  and  methods traverse the tree in the opposite direction:  retrieves a compound plug from a child plug, and  retrieves an array plug from an element plug.Since connections to arrays are sparse, element plugs have both logical and physical indexes. The logical indexes are used by MEL, and are sparse. Physical indexes, on the other hand, are not sparse. It is guaranteed that the physical indexes will range from 0 to  - 1. Using the physical indexes, iterating over the element plugs in an array is easy: This is equivalent to calling  since the bracket operator uses physical indexes.The ancestry of a plug is the tree above the plug: any parents or arrays which this plug belongs to. The  method provides quick access to element plugs without walking the plug tree. A plug does not need to exist in the datablock or plug tree in order to be constructed using selectByLogicalIndex, but once a value is requested or set on the plug, it will be added to the datablock if it was not there already. For example:Once a value has been added to an array plug, it will usually remain in the datablock as long as the scene is open. The exception is for attributes that have their disconnect behavior set to kDelete; data for these attributes will be deleted when their connection is broken. When a file is saved, only array values that are not at their default values will be written out. Therefore, the number of elements in an array plug may change when the file is read in again.'''
    def __init__(self):
        pass


    def isArray(self): 
        '''isArray(self) -> bool
Returns: true 
false


This method determines if the plug is an array plug. Array plugs refer to array attributes and contain element plugs.'''
        pass

    def asMAngle(self, ctx): 
        '''asMAngle(self, ctx) -> MAngle
Returns: Value of plug as an MAngle

Arguments:
	[in]	ctx = MDGContext


Retrieve the current value of the attribute this plug references.'''
        pass

    def elementByLogicalIndex(self, index): 
        '''elementByLogicalIndex(self, index) -> MPlug
Returns: A plug with the given index

Arguments:
	[in]	index = int


This method will find and return a plug with the given logical index. The logical index is the sparse array index used in MEL scripts. If a plug does not exist at the given Index, Maya will create a plug at that index. This is not the case with  elementByPhysicalIndex() . If needed, elementByLogicalIndex can be used to expand an array plug on a node. It is important to note that Maya assumes that all such plugs serve a purpose and it will not free non-networked plugs that result from such an array expansion.'''
        pass

    def setMDataHandle(self, handle): 
        '''setMDataHandle(self, handle)
Arguments:
	[in]	handle = MDataHandle


Set the current value of the attribute this plug references with the values in the handle. This method is most useful when the plug is an array plug, and you've filled the handle with data. Sending the value using this version of setValue will set the handle's data into the datablock and send out the appropriate attributeChanged messages to update the UI related to the attribute.'''
        pass

    def attribute(self): 
        '''attribute(self) -> MObject
Returns: The attribute that this plug refers to.


This method returns the attribute that this plug refers to.'''
        pass

    def child(self, index): 
        '''child(self, index) -> MPlug

Arguments:
	[in]	index = int


Returns a plug to a given attribute that is a child of this plug. This method is only valid for compound plugs.'''
        pass

    def __getitem__(self, physicalIndex): 
        '''__getitem__(self, physicalIndex) -> MPlug
Returns: A plug with the given index 

Arguments:
	[in]	physicalIndex = int


This method will find and return a plug with the given physical index. This is the same as the  elementByPhysicalIndex  method.'''
        pass

    def asFloat(self, ctx): 
        '''asFloat(self, ctx) -> float
Returns: Value of plug as a float

Arguments:
	[in]	ctx = MDGContext


Retrieve the current value of the attribute this plug references.'''
        pass

    def isConnected(self): 
        '''isConnected(self) -> bool
Returns: true If this plug is connected to another plug 
false If this plug is not connected to another plug


Determines if this plug is connected to one or more plugs.'''
        pass

    def connectedTo(self, array, asDst, asSrc): 
        '''connectedTo(self, array, asDst, asSrc) -> bool
Returns: true If the plug has connections as either source or destination. Note that the array is filled in only with the type of connecting plugs requested by asSrc and asDst. Therefore, the method could return true while the array has nothing in it if, for example, the plug has connections as source but the user passes asSrc = false to the method. The parameters asSrc and asDst have no effect on the boolean return value. Setting one true and one false and then checking the length of the array after calling this method is a way to determine whether the connections are source or destination. 
false If this plug has no connections

Arguments:
	[in]	array = MPlugArray
	[in]	asDst = bool
	[in]	asSrc = bool


This method finds all of the plugs that this plug is connected with. This method will always produce the networked version of the connected plugs.'''
        pass

    def isProcedural(self): 
        '''isProcedural(self) -> bool
Returns: true 
false


This method determines if the plug is a procedural plug. A procedural plug is one which is created by Maya's internal procedures or by the nodes themselves and which should not be saved to or restored from files.'''
        pass

    def numConnectedChildren(self): 
        '''numConnectedChildren(self) -> int
Returns: Total number of children


Return the number of children of this plug that are connected in the dependency graph.'''
        pass

    def setMObject(self, val): 
        '''setMObject(self, val)
Arguments:
	[in]	val = MObject


Set the current value of the attribute this plug references.'''
        pass

    def setBool(self, val): 
        '''setBool(self, val)
Arguments:
	[in]	val = bool


Set the current value of the attribute this plug references.'''
        pass

    def array(self): 
        '''array(self) -> MPlug
Returns: The array of this plug.


Returns the array to which this element plug belongs. This method is only valid for networked element plugs.'''
        pass

    def asString(self, ctx): 
        '''asString(self, ctx) -> MString
Returns: Value of plug as an MString

Arguments:
	[in]	ctx = MDGContext


Retrieve the current value of the attribute this plug references.'''
        pass

    def asDouble(self, ctx): 
        '''asDouble(self, ctx) -> double
Returns: Value of plug as a double

Arguments:
	[in]	ctx = MDGContext


Retrieve the current value of the attribute this plug references.'''
        pass

    def setMTime(self, val): 
        '''setMTime(self, val)
Arguments:
	[in]	val = MTime


Set the current value of the attribute this plug references.'''
        pass

    def isCachingFlagSet(self): 
        '''isCachingFlagSet(self) -> bool
Returns: true caching flag has been set 
false caching flag has not been set


Returns true if this plug or its attribute has its caching flag set.'''
        pass

    def setMDistance(self, val): 
        '''setMDistance(self, val)
Arguments:
	[in]	val = MDistance


Set the current value of the attribute this plug references.'''
        pass

    def asChar(self, ctx): 
        '''asChar(self, ctx) -> char
Returns: Value of plug as a char

Arguments:
	[in]	ctx = MDGContext


Retrieve the current value of the attribute this plug references.'''
        pass

    def parent(self): 
        '''parent(self) -> MPlug
Returns: The parent of this plug.


Returns the parent plug. The parent plug will always be a compound plug. This method is only valid for networked child plugs.'''
        pass

    def getExistingArrayAttributeIndices(self, indices): 
        '''getExistingArrayAttributeIndices(self, indices) -> int
Returns: The number of set/connected elements

Arguments:
	[in]	indices = MIntArray


This method will return a list of the logical indices of the elements in an array attribute that are either connected or have had their value set. This method is useful when the logical indices of connected/set elements are sparse.'''
        pass

    def isDynamic(self): 
        '''isDynamic(self) -> bool
Returns: true If the attribute is dynamic 
false If this attribute is not added by user.


Determines whether the attribute is of dynamic type or not.'''
        pass

    def isFromReferencedFile(self): 
        '''isFromReferencedFile(self) -> bool
Returns: true plug was created within a referenced file 
false plug was created within the current scene


This method determines whether this plug came from a referenced file. A plug is considered to have come from a referenced file if it is connected and that connection was made within a referenced file.'''
        pass

    def isCompound(self): 
        '''isCompound(self) -> bool
Returns: true 
false


This method determines if the plug is a compound plug. Compound plugs refer to compound attributes and have child plugs.'''
        pass

    def numConnectedElements(self): 
        '''numConnectedElements(self) -> int
Returns: Total number of elements


Return the total number of connected element plugs belonging to this array plug.'''
        pass

    def setChar(self, val): 
        '''setChar(self, val)
Arguments:
	[in]	val = char


Set the current value of the attribute this plug references.'''
        pass

    def numElements(self): 
        '''numElements(self) -> int
Returns: Total number of elements


Return the total number of elements in the datablock of this array plug. The return count will include all existing non-connected elements plus connected elements if they have been evaluated. It will not include connected elements that have not yet been placed into the datablock. The method  MPlug::evaluateNumElements  can be used in the sitution where you want an accurate count that includes all connected elements.'''
        pass

    def isLocked(self): 
        '''isLocked(self) -> bool
Returns: true If this plug's value is locked 
false If this plug's value is not locked


Determines the locked state of this plug's value. A plug's locked state determines whether or not the plug's value can be changed.'''
        pass

    def setMAngle(self, val): 
        '''setMAngle(self, val)
Arguments:
	[in]	val = MAngle


Set the current value of the attribute this plug references.'''
        pass

    def isKeyable(self): 
        '''isKeyable(self) -> bool
Returns: true If this plug is keyable 
false If this plug is not keyable


Determines if this plug is keyable. The default keyability of a plug is determined by its attribute, and can be retrieved using  MFnAttribute::isKeyable . Keyable plugs will be keyed by AutoKey and the Set Keyframe UI. Non-keyable plugs prevent the user from setting keys via the obvious UI provided for keying. Being non-keyable is not a hard block against adding keys to an attribute.'''
        pass

    def isElement(self): 
        '''isElement(self) -> bool
Returns: true 
false


This method determines if the plug is an element plug. Element plugs refer to array attributes and are members of array plugs.'''
        pass

    def asMTime(self, ctx): 
        '''asMTime(self, ctx) -> MTime
Returns: Value of plug as an MTime

Arguments:
	[in]	ctx = MDGContext


Retrieve the current value of the attribute this plug references.'''
        pass

    def asMDistance(self, ctx): 
        '''asMDistance(self, ctx) -> MDistance
Returns: Value of plug as an MDistance

Arguments:
	[in]	ctx = MDGContext


Retrieve the current value of the attribute this plug references.'''
        pass

    def isNetworked(self): 
        '''isNetworked(self) -> bool
Returns: true 
false


This method determines if the plug is networked or non-networked.'''
        pass

    def setString(self, val): 
        '''setString(self, val)
Arguments:
	[in]	val = MString


Set the current value of the attribute this plug references.'''
        pass

    def node(self): 
        '''node(self) -> MObject
Returns: A pointer to this plug's dependency node.


Returns the dependency node that this plug belongs to.'''
        pass

    def setKeyable(self, keyable): 
        '''setKeyable(self, keyable)
Arguments:
	[in]	keyable = bool


This overrides the default keyability of a plug set with  MFnAttribute::setKeyable . Keyable plugs will be keyed by AutoKey and the Set Keyframe UI. Non-keyable plugs prevent the user from setting keys via the obvious UI provided for keying. Being non-keyable is not a hard block against adding keys to an attribute.'''
        pass

    def __neq__(self, attr): 
        '''__neq__(self, attr) -> bool
Returns: true If the plug's attribute is not equal 
false If the plug's attribute is equal 

Arguments:
	[in]	attr = MObject


The inequality operator for a plug and an attribute. This actually compares the plug's attribute against the other attribute.'''
        pass

    def selectAncestorLogicalIndex(self, index, attribute): 
        '''selectAncestorLogicalIndex(self, index, attribute)
Arguments:
	[in]	index = int
	[in]	attribute = MObject


This method is a convenience routine to allow quick iteration and construction of plugs with array plugs in their ancestry. It selects a plug into the current object by changing an ancestor array's logical index.'''
        pass

    def getSetAttrCmds(self, valueSelector, useLongNames, cmds): 
        '''getSetAttrCmds(self, valueSelector, useLongNames, cmds)
Arguments:
	[out]	cmds = MStringArray
	[in]	valueSelector = MPlug.MValueSelector
	[in]	useLongNames = bool


Returns an array of strings containing  setAttr  commands for this plug and all of its descendent plugs.'''
        pass

    def kChildrenNotFreeToChange(self):
        '''This is an enum of FreeToChangeState.
Description: Some of the children are not free to change.
Value: 2'''
        pass

    def kNotFreeToChange(self):
        '''This is an enum of FreeToChangeState.
Description: Some of the tested plugs are not free to change.
Value: 1'''
        pass

    def kFreeToChange(self):
        '''This is an enum of FreeToChangeState.
Description: All tested plugs are free to change.
Value: 0'''
        pass

    class FreeToChangeState:
        '''Non-functional class.  Values for this enum:
        kChildrenNotFreeToChange
        kNotFreeToChange
        kFreeToChange
'''
        def __init__(self):
            pass

    def setLocked(self, locked): 
        '''setLocked(self, locked)
Arguments:
	[in]	locked = bool


Sets the locked state for this plug's value. A plug's locked state determines whether or not the plug's value can be changed.'''
        pass

    def destructHandle(self, mHandle): 
        '''destructHandle(self, mHandle)
Arguments:
	[in]	mHandle = MDataHandle

'''
        pass

    def connectionByPhysicalIndex(self, index): 
        '''connectionByPhysicalIndex(self, index) -> MPlug
Returns: A plug with the given index

Arguments:
	[in]	index = int


This method will find and return a connected plug with the given physical index for its connection. The index can range from 0 to  numConnectedElements()  - 1. This method varies from elementByPhysicalIndex in that elementByPhysicalIndex will return plugs pointing to all existing data in the datablock regardless of whether the plug is connected or not.'''
        pass

    def constructHandle(self, mBlock): 
        '''constructHandle(self, mBlock) -> MDataHandle

Arguments:
	[in]	mBlock = MDataBlock


This method returns a data handle constructed for this plug.'''
        pass

    def isChannelBoxFlagSet(self): 
        '''isChannelBoxFlagSet(self) -> bool
Returns: true channel box flag has been set 
false channel box flag has not been set


Returns true if this plug or its attribute has its channel box flag set. Attributes will appear in the channel box if their channel box flag is set or if they are keyable.'''
        pass

    def elementByPhysicalIndex(self, index): 
        '''elementByPhysicalIndex(self, index) -> MPlug
Returns: A plug with the given index

Arguments:
	[in]	index = int


This method will find and return a plug with the given physical index. The index can range from 0 to  numElements()  - 1. This function is particularly useful for iteration through the element plugs of an array plug. It is equivalent to operator [] (int) This method is only valid for array plugs.'''
        pass

    def setCaching(self, isCaching): 
        '''setCaching(self, isCaching)
Arguments:
	[in]	isCaching = bool


Sets whether this plug is cached internally. Note: turning caching on for a plug will force the plug to become networked. Network plugs take longer to look up in the DG; therefore you should only make a plug cached only if you are certain that the network plug look-up will take less than the saved evaluation cost.'''
        pass

    def logicalIndex(self): 
        '''logicalIndex(self) -> int
Returns: The logical array index of the element this plug refers to


Returns the logical index of the element this plug refers to. The logical index is a sparse index, equivalent to the array index used in MEL.'''
        pass

    def isIgnoredWhenRendering(self): 
        '''isIgnoredWhenRendering(self) -> bool
Returns: true If connected, the attribute should be ingored during rendering. 
false If connected, the attribute should not be ingored during rendering.


Determines whether a connection to the attribute should be ignored during rendering.'''
        pass

    def __eq__(self, attr): 
        '''__eq__(self, attr) -> bool
Returns: true If the plug's attribute is equal 
false If the plug's attribute is not equal 

Arguments:
	[in]	attr = MObject


Comparison operator for a plug and an attribute. This actually compares the plug's attribute against the other attribute.'''
        pass

    def isChild(self): 
        '''isChild(self) -> bool
Returns: true 
false


This method determines if the plug is a child plug. A child plug's parent is always a compound plug.'''
        pass

    def setMPxData(self, val): 
        '''setMPxData(self, val)
Arguments:
	[in]	val = MPxData


Set the current value of the attribute this plug references.'''
        pass

    def asMObject(self, ctx): 
        '''asMObject(self, ctx) -> MObject
Returns: Value of plug as an MObject

Arguments:
	[in]	ctx = MDGContext


Retrieve the current value of the attribute this plug references.'''
        pass

    def info(self): 
        '''info(self) -> MString
Returns: Returns a string containing dependency node and attribute information for this plug.


This method returns a string containing the name of the node this plug belongs to and the attributes that the plug refers to. The string is of the form dependNode:atr1.atr2[].attr3 ...'''
        pass

    def name(self): 
        '''name(self) -> MString
Returns: The name of this node


Returns the name of this plug in the form "<i>nodeName</i>.<i>attributeName</i>".'''
        pass

    def asBool(self, ctx): 
        '''asBool(self, ctx) -> bool
Returns: Value of plug as a bool

Arguments:
	[in]	ctx = MDGContext


Retrieve the current value of the attribute this plug references.'''
        pass

    def asShort(self, ctx): 
        '''asShort(self, ctx) -> short
Returns: Value of plug as a short

Arguments:
	[in]	ctx = MDGContext


Retrieve the current value of the attribute this plug references.'''
        pass

    def setShort(self, val): 
        '''setShort(self, val)
Arguments:
	[in]	val = short


Set the current value of the attribute this plug references.'''
        pass

    def setDouble(self, val): 
        '''setDouble(self, val)
Arguments:
	[in]	val = double


Set the current value of the attribute this plug references.'''
        pass

    def isFreeToChange(self, checkParents, checkChildren): 
        '''isFreeToChange(self, checkParents, checkChildren) -> MPlug.FreeToChangeState
Returns: kFreeToChange All tested plugs are free to change. 
kNotFreeToChange Some of the tested plugs are not free to change. 
kChildrenNotFreeToChange Some of the children are not free to change.

Arguments:
	[in]	checkParents = bool
	[in]	checkChildren = bool


Returns true if the plug's value is allowed to be set directly. A plug isFreeToChange if it is not locked, and it is not a destination or if it is a destination, then it must be a special case (such as connected to an anim curve).'''
        pass

    def setAttribute(self, attribute): 
        '''setAttribute(self, attribute)
Arguments:
	[in]	attribute = MObject


This method is a convenience routine to allow quick movement between attributes on a single node. If the current plug is a networked plug, it becomes a new non-networked plug referring to the requested attribute. If the current plug is a non-networked plug, it is changed to refer to the requested attribute.'''
        pass

    def setInt(self, val): 
        '''setInt(self, val)
Arguments:
	[in]	val = int


Set the current value of the attribute this plug references.'''
        pass

    def numChildren(self): 
        '''numChildren(self) -> int
Returns: Total number of children


Return the total number of children of this compound plug.'''
        pass

    def kNonDefault(self):
        '''This is an enum of MValueSelector.
Description: Non default values.
Value: 1'''
        pass

    def kAll(self):
        '''This is an enum of MValueSelector.
Description: All values.
Value: 0'''
        pass

    def kChanged(self):
        '''This is an enum of MValueSelector.
Description: Changed values.
Value: 2'''
        pass

    def kLastAttrSelector(self):
        '''This is an enum of MValueSelector.
Description: Last value, for counting.
Value: 3'''
        pass

    class MValueSelector:
        '''Non-functional class.  Values for this enum:
        kNonDefault
        kAll
        kChanged
        kLastAttrSelector
'''
        def __init__(self):
            pass

    def isNull(self): 
        '''isNull(self) -> bool
Returns: true this plug is not valid 
false this plug is valid


This method determines whether this plug is valid. A plug is valid if it refers to an attribute.'''
        pass

    def evaluateNumElements(self): 
        '''evaluateNumElements(self) -> int
Returns: Total number of elements


Return the total number of elements in the datablock of this array plug. The return count will include both connected and non-connected elements, and will perform an evaluate in order to make sure that the datablock is as up-to-date as possible since some nodes do not place array elements into the datablock until the attribute is evaluated.'''
        pass

    def setFloat(self, val): 
        '''setFloat(self, val)
Arguments:
	[in]	val = float


Set the current value of the attribute this plug references.'''
        pass

    def setChannelBox(self, inChannelBox): 
        '''setChannelBox(self, inChannelBox)
Arguments:
	[in]	inChannelBox = bool


Sets whether this plug is displayed in the channel box. This overrides the default display of a plug set with  MFnAttribute::setChannelBox . Keyable attributes are always shown in the channel box so this flag is ignored on keyable plugs.'''
        pass

    def partialName(self, includeNodeName, includeNonMandatoryIndices, includeInstancedIndices, useAlias, useFullAttributePath, useLongNames): 
        '''partialName(self, includeNodeName, includeNonMandatoryIndices, includeInstancedIndices, useAlias, useFullAttributePath, useLongNames) -> MString

Arguments:
	[in]	includeNodeName = bool
	[in]	includeNonMandatoryIndices = bool
	[in]	includeInstancedIndices = bool
	[in]	useAlias = bool
	[in]	useFullAttributePath = bool
	[in]	useLongNames = bool


By default, this method returns the shortest possible name for the plug, but its parameters can be used to add parts back in.'''
        pass

    def asInt(self, ctx): 
        '''asInt(self, ctx) -> int
Returns: Value of plug as an int

Arguments:
	[in]	ctx = MDGContext


Retrieve the current value of the attribute this plug references.'''
        pass

    def setNumElements(self, elements): 
        '''setNumElements(self, elements)
Arguments:
	[in]	elements = int


The method is used to pre-allocate the number of elements that an array plug will contain. The plug passed to this method must be an array plug and there must be no elements already allocated.'''
        pass

class MPlugArray:
    '''Array of MPlugs data type. This class implements an array of MPlugs. Common convenience functions are available, and the implementation is compatible with the internal Maya implementation so that it can be passed efficiently between plugins and internal maya data structures. '''
    def __init__(self):
        pass


    def insert(self, element, index): 
        '''insert(self, element, index)
Arguments:
	[in]	element = MPlug
	[in]	index = int


Inserts a new value into the array at the given index. The initial element at that index, and all following elements, are shifted towards the last. If the array cannot be expanded in size by 1 element, then the insert will fail and the existing array will remain unchanged.'''
        pass

    def set(self, element, index): 
        '''set(self, element, index)
Arguments:
	[in]	element = MPlug
	[in]	index = int


Sets the value of the indicated element to the indicated  MPlug  value.'''
        pass

    def __getitem__(self, index): 
        '''__getitem__(self, index) -> MPlug
Returns: The value of the indicated element 

Arguments:
	[in]	index = int


Index operator. Returns the value of the element at the given index. No range checking is done - valid indices are 0 to  length() -1.'''
        pass

    def clear(self): 
        '''clear(self)

Clear the contents of the array. After this operation the length method will return 0. This does not change the amount of memory allocated to the array, only the number of valid elements in it.'''
        pass

    def sizeIncrement(self): 
        '''sizeIncrement(self) -> int


Return the size by which the array will be expanded whenever expansion is necessary.'''
        pass

    def remove(self, index): 
        '''remove(self, index)
Arguments:
	[in]	index = int


Remove the array element at the given index. All array elements following the removed element are shifted toward the first element.'''
        pass

    def length(self): 
        '''length(self) -> int


Returns the number of elements in the instance.'''
        pass

    def setSizeIncrement(self, newIncrement): 
        '''setSizeIncrement(self, newIncrement)
Arguments:
	[in]	newIncrement = int


Set the size by which the array will be expanded whenever expansion is necessary.'''
        pass

    def setLength(self, length): 
        '''setLength(self, length)
Arguments:
	[in]	length = int


Set the length of the array. This will grow and shrink the array as desired. Elements that are grown have uninitialized values, while those which are shrunk will lose the data contained in the deleted elements (ie. it will release the memory).'''
        pass

    def append(self, element): 
        '''append(self, element)
Arguments:
	[in]	element = MPlug


Adds a new element to the end of the array. If the array cannot be expanded in size by 1 element, then the append will fail and the existing array will remain unchanged.'''
        pass

class MPoint:
    '''Implementation of a point. This class provides an implementation of a point. Numerous convienence operators are provided to help with the manipulation of points. This includes operators that work with the MVector and MMatrix classes.All methods that query the point are threadsafe, all methods that modify the point are not threadsafe. '''
    def __init__(self):
        pass


    def rationalize(self): 
        '''rationalize(self) -> MPoint

'''
        pass

    def homogenize(self): 
        '''homogenize(self) -> MPoint


If this point instance is of the form P(x, y, z, W) (ie. is in rational or (for W==1) cartesian form), for some scale factor W != 0, then it is reset to be P(W*x, W*y, W*z, W). 
  Reprocessed example  
 Examples: 
 
   
 apiMeshShapeUI.cpp , and  apiSimpleShapeUI.cpp . 
 
'''
        pass

    def __getitem__(self, i): 
        '''__getitem__(self, i) -> double
Returns: The value of the indicated component of the instance. 

Arguments:
	[in]	i = int


The index operator.  
 If the argument is 0 it will return the x component of the constant instance.  
 If the argument is 1 it will return the y component of the constant instance.  
 If the argument is 2 it will return the z component of the constant instance.  
 If the argument is 3 it will return the w component of the constant instance.  
 Otherwise it will return the x component of the point. 
 
 Parameters: 
 
 [in]   i   Value indicating which component to return. 
 
 
 Returns: The value of the indicated component of the instance.  
'''
        pass

    def get(self, dest): 
        '''get(self, dest)
Arguments:
	[out]	dest = float4


Copy the values of x, y, z, and w from the instance to the four elements of the given array of floats.'''
        pass

    def distanceTo(self, other): 
        '''distanceTo(self, other) -> double
Returns: The distance between the two points. 

Arguments:
	[in]	other = MPoint


Return the distance between this instance and the point passed as an argument.'''
        pass

    def __rmult__(self, right): 
        '''__rmult__(self, right) -> MPoint
Returns: A point representing the product 

Arguments:
	[in]	right = MMatrix


The in-place multiplication operator for computing the product of this point instance with the given matrix.'''
        pass

    def cartesianize(self): 
        '''cartesianize(self) -> MPoint

'''
        pass

    def isEquivalent(self, other, tol): 
        '''isEquivalent(self, other, tol) -> bool
Returns: True if the points are equal within the given tolerance and false otherwise. 

Arguments:
	[in]	other = MPoint
	[in]	tol = double


Returns true if this instance of the point passed as an argument represent the same position within the specified tolerance.'''
        pass

    def __radd__(self, vector): 
        '''__radd__(self, vector) -> MPoint
Returns: A reference to the resulting point. 

Arguments:
	[in]	vector = MVector


The in-place addition operator for adding an  MVector  to an  MPoint . The current instance is translated from its original position by the vector.'''
        pass

    def __div__(self, scale): 
        '''__div__(self, scale) -> MPoint
Returns: The resulting point. 

Arguments:
	[in]	scale = double


The division operator that allows the vector to by scaled by the given double parameter. The x, y, and z components are each divided by the parameter. The w component remains unchanged.'''
        pass

    def __rsub__(self, vector): 
        '''__rsub__(self, vector) -> MPoint
Returns: A reference to the resulting point. 

Arguments:
	[in]	vector = MVector


The in-place subtraction operator for subtracting an  MVector  from an  MPoint . The current instance is translated from its original position by the inverse of the vector.'''
        pass

    def __mul__(self, right): 
        '''__mul__(self, right) -> MPoint
Returns: A point representing the product 

Arguments:
	[in]	right = MMatrix


The multiplication operator for computing the product of this point instance with the given matrix.'''
        pass

    def __add__(self, other): 
        '''__add__(self, other) -> MPoint
Returns: The resulting point. 

Arguments:
	[in]	other = MVector


The addition operator for adding an  MVector  to an  MPoint . A new point is returned whose position is that of the original point translated by the vector.'''
        pass

    def __sub__(self, other): 
        '''__sub__(self, other) -> MPoint
Returns: The resulting point. 

Arguments:
	[in]	other = MVector


The addition operator for subtracting an  MVector  from an  MPoint . A new point is returned whose position is that of the original point translated by the inverse of the vector.'''
        pass

    def __eq__(self, other): 
        '''__eq__(self, other) -> bool
Returns: True if all of the x, y, z components of the two points are identical. 

Arguments:
	[in]	other = MPoint


The equality operator.'''
        pass

    def __neq__(self, other): 
        '''__neq__(self, other) -> bool
Returns: True if any of the x, y, z components of the two points are not identical. 

Arguments:
	[in]	other = MPoint


The inequality operator.'''
        pass

class MPointArray:
    '''Array of MPoint data type. This class implements an array of MPoints. Common convenience functions are available, and the implementation is compatible with the internal Maya implementation so that it can be passed efficiently between plugins and internal maya data structures. '''
    def __init__(self):
        pass


    def insert(self, element, index): 
        '''insert(self, element, index)
Arguments:
	[in]	element = MPoint
	[in]	index = int


Inserts a new value into the array at the given index. The initial element at that index, and all following elements, are shifted towards the last. If the array cannot be expanded in size by 1 element, then the insert will fail and the existing array will remain unchanged.'''
        pass

    def set(self, val, index): 
        '''set(self, val, index)
Arguments:
	[in]	val = float4
	[in]	index = int


Sets the value of the indicated element to the indicated value. The x component of the element is set to val[0], the y component to val[1], the z component to val[2], and the w component to val[3].'''
        pass

    def get(self, dest): 
        '''get(self, dest)
Arguments:
	[out]	dest = float


Copy the elements of the array into the C++ array of float arrays. No checking is done to ensure that the destination C++ array of float arrays is large enough to hold all the elements of the instance.'''
        pass

    def clear(self): 
        '''clear(self)

Clear the contents of the array. After this operation the length method will return 0. This does not change the amount of memory allocated to the array, only the number of valid elements in it.'''
        pass

    def sizeIncrement(self): 
        '''sizeIncrement(self) -> int


Return the size by which the array will be expanded whenever expansion is necessary.'''
        pass

    def remove(self, index): 
        '''remove(self, index)
Arguments:
	[in]	index = int


Remove the array element at the given index. All array elements following the removed element are shifted toward the first element.'''
        pass

    def length(self): 
        '''length(self) -> int


Returns the number of elements in the instance.'''
        pass

    def MPoint(self, index): 
        '''MPoint(self, index) -> const
Returns: The value of the indicated element. 

Arguments:
	[in]	index = int


Index operator. Returns the value of the element at the given index. No range checking is done - valid indices are 0 to  length() -1.'''
        pass

    def setSizeIncrement(self, newIncrement): 
        '''setSizeIncrement(self, newIncrement)
Arguments:
	[in]	newIncrement = int


Set the size by which the array will be expanded whenever expansion is necessary.'''
        pass

    def copy(self, source): 
        '''copy(self, source)
Arguments:
	[in]	source = MPointArray


Copy the contents of the source array to this array.'''
        pass

    def setLength(self, length): 
        '''setLength(self, length)
Arguments:
	[in]	length = int


Set the length of the array. This will grow and shrink the array as desired. Elements that are grown have uninitialized values, while those which are shrunk will lose the data contained in the deleted elements (ie. it will release the memory).'''
        pass

    def append(self, x, y, z, w): 
        '''append(self, x, y, z, w)
Arguments:
	[in]	x = double
	[in]	y = double
	[in]	z = double
	[in]	w = double


Adds a new element to the end of the array. The appended element has the indicated values for its x,y,z and w components. The x component of the element is set to x, the y component to y, the z component to z, and the w component to w.'''
        pass

class MPolyMessage:
    '''Polygon component id change messages. This class is used to register callbacks for poly component id modification messages.There is 1 add callback method which will add callbacks for the following messages:To remove a callback use MMessage::removeCallback. All callbacks that are registered by a plug-in must be removed by that plug-in when it is unloaded. Failure to do so will result in a fatal error. '''
    def __init__(self):
        pass


    def addPolyComponentIdChangedCallback(self, node, wantIdModifications, count, func, clientData): 
        '''addPolyComponentIdChangedCallback(self, node, wantIdModifications, count, func, clientData) -> MCallbackId

Arguments:
	[in]	node = MObject
	[in]	wantIdModifications = bool
	[in]	count = int
	[in]	func = MMessage.MComponentFunction
	[in]	clientData = void


This method registers a callback that should be called whenever a poly component id is modified.'''
        pass

    def enum(self): 
        '''enum(self) -> anonymous


Values passed in addPolyComponentIdChangeCallback's "wantIdModifications" array to indicate which component id changes should trigger the callback.  Enumerator:  
 
  doxytag: member="kVertexIndex" ref="ef2efbce267a34fec3c54d082d99666dfd406c5c4d2fbd731b3dfbe93a40c78f" args=""  kVertexIndex   
vertex component id changed  
  doxytag: member="kEdgeIndex" ref="ef2efbce267a34fec3c54d082d99666d26aca3a30f456a4d33035fb0327e782e" args=""  kEdgeIndex   
edge component id changed  
  doxytag: member="kFaceIndex" ref="ef2efbce267a34fec3c54d082d99666daf7526f60bba0b0059df2167b43552b7" args=""  kFaceIndex   
face component id changed  
  doxytag: member="kLastErrorIndex" ref="ef2efbce267a34fec3c54d082d99666d01242bfb7aed0c2e86fbc3d5a7ecb105" args=""  kLastErrorIndex   
   
 
 
'''
        pass

    def deletedId(self): 
        '''deletedId(self) -> int


This method returns a constant which is to be used to determine if a component id has been deleted. Compare component ids returned by the callback with the value return by this method. If they are the same then, the component id has been deleted.'''
        pass

    def addPolyTopologyChangedCallback(self, node, func, clientData): 
        '''addPolyTopologyChangedCallback(self, node, func, clientData) -> MCallbackId

Arguments:
	[in]	node = MObject
	[in]	func = MMessage.MNodeFunction
	[in]	clientData = void


This method registers a callback that will be called whenever the topology of a meshShape changes.'''
        pass

class MQuaternion:
    '''Quaternion math. This class provides methods for working with Quaternions. Quaternions can be used to specify orientations and rotations of 3-D objects relative to a starting reference, similar to the way that cartesian vectors can be used to specify positions and translations of 3-D objects relative to an origin. Quaternions represent orientations as a single rotation, just as rectangular co-ordinates represent position as a single vector. '''
    def __init__(self):
        pass


    identity = ''
    '''The multiplicative identity. '''

    def scaleIt(self, scale): 
        '''scaleIt(self, scale) -> MQuaternion
Returns: A reference to the quaternion that has been scaled 

Arguments:
	[in]	scale = double


Performs an in place scaling of the quaternion. The result is a quaternion whose x, y, z, and w values have been scaled by the specified amount.'''
        pass

    def negateIt(self): 
        '''negateIt(self) -> MQuaternion


Performs an in place negation of the quaternion. The result is a quaternion whose x, y, z, and w values have been negated.'''
        pass

    def conjugateIt(self): 
        '''conjugateIt(self) -> MQuaternion


Performs an in place conjugation of this quaternion. The result is a quaternion whose x, y, and z values have been negated.'''
        pass

    def conjugate(self): 
        '''conjugate(self) -> MQuaternion


Returns the conjugate of this quaternion. The result is a quaternion whose x, y, and z values have been negated.'''
        pass

    def setAxisAngle(self, axis, theta): 
        '''setAxisAngle(self, axis, theta) -> MQuaternion
Returns: A reference to the quaternion that has had its axis and angle set 

Arguments:
	[in]	axis = MVector
	[in]	theta = double


Sets this quaternion to be the rotation as expressed by a pivot axis and a rotation theta (in radians) about that axis. If the axis is too small the quaternion returned will be the identity quaternion.'''
        pass

    def asEulerRotation(self): 
        '''asEulerRotation(self) -> MEulerRotation

'''
        pass

    def __neq__(self, other): 
        '''__neq__(self, other) -> bool
Returns: true the quaternions are not identical 
false the quaternions are identical 

Arguments:
	[in]	other = MQuaternion


The quaternion inequality operator. This returns false if all four of the x, y, z, and w components are identical.'''
        pass

    def inverse(self): 
        '''inverse(self) -> MQuaternion


Returns the inverse of this quaternion.'''
        pass

    def log(self): 
        '''log(self) -> MQuaternion


Returns the natural log of a quaternion. The precondition for using this method is that the quaternion must be normalized.'''
        pass

    def normalizeIt(self): 
        '''normalizeIt(self) -> MQuaternion


Performs an in place normalization of this quaternion. The result is a quaternion of unit length.'''
        pass

    def normal(self): 
        '''normal(self) -> MQuaternion


Returns the normal of this quaternion. The result is a quaternion of unit length.'''
        pass

    def asMatrix(self): 
        '''asMatrix(self) -> MMatrix


Converts a quaternion to a 4X4 homogeneous rotation matrix. The construction of the matrix assumes that the vectors are going to be multiplied on the left side of the matrix. If the quaternion's length has degenerated, this method will still produce a well behaved matrix.'''
        pass

    def getAxisAngle(self, axis, theta): 
        '''getAxisAngle(self, axis, theta) -> bool
Returns: true angle != 0 
false angle == 0 (uses arbitrary axis, if given axis not valid) 

Arguments:
	[out]	axis = MVector
	[out]	theta = double


Converts this quaternion into a user understandable representation. That is, the quaternion is represented as a pivot vector 'axis' and a rotation 'theta' (in radians) about that pivot vector.'''
        pass

    def setToZAxis(self, theta): 
        '''setToZAxis(self, theta) -> MQuaternion
Returns: A reference to the quaternion that has been set to rotate about the Z axis by the given amount 

Arguments:
	[in]	theta = double


Sets this quaternion to be the rotation about the Z axis of theta (in radians). If the length of the axis is too small the quaternion returned will be the identity quaternion.'''
        pass

    def __getitem__(self, i): 
        '''__getitem__(self, i) -> double
Returns: The component of the quaternion corresponding to the index 

Arguments:
	[in]	i = int


The index operator. If its argument is 0 it will return the x component of the quaternion. If its argument is 1 it will return the y component of the quaternion. If its argument is 2 it will return the z component of the quaternion. If its argument is 3 it will return the w component of the quaternion.'''
        pass

    def get(self, dest): 
        '''get(self, dest)
Arguments:
	[out]	dest = double4


Extracts the x, y, z, and w components of the quaternion and places them in elements 0, 1, 2, and 3 of the double array passed.'''
        pass

    def setToYAxis(self, theta): 
        '''setToYAxis(self, theta) -> MQuaternion
Returns: A reference to the quaternion that has been set to rotate about the Y axis by the given amount 

Arguments:
	[in]	theta = double


Sets this quaternion to be the rotation about the Y axis of theta (in radians). If the length of the axis is too small the quaternion returned will be the identity quaternion.'''
        pass

    def isEquivalent(self, other, tolerance): 
        '''isEquivalent(self, other, tolerance) -> bool
Returns: true the quaternions are equivalent 
false the quaternions are not equivalent 

Arguments:
	[in]	other = MQuaternion
	[in]	tolerance = double


This method returns true if this quaternion is equal, within some given tolerance, to the other quaternion.'''
        pass

    def __add__(self, other): 
        '''__add__(self, other) -> MQuaternion
Returns: The sum of the two quaternions 

Arguments:
	[in]	other = MQuaternion


The quaternion addition operator.'''
        pass

    def invertIt(self): 
        '''invertIt(self) -> MQuaternion


Performs an in place inversion of this quaternion.'''
        pass

    def __eq__(self, other): 
        '''__eq__(self, other) -> bool
Returns: true the quaternions are identical 
false the quaternions are not identical 

Arguments:
	[in]	other = MQuaternion


The quaternion equality operator. This returns true if all four of the x, y, z, and w components are identical.'''
        pass

    def setToXAxis(self, theta): 
        '''setToXAxis(self, theta) -> MQuaternion
Returns: A reference to the quaternion that has been set to rotate about the X axis by the given amount 

Arguments:
	[in]	theta = double


Sets this quaternion to be the rotation about the X axis of theta (in radians). If the length of the axis is too small the quaternion returned will be the identity quaternion.'''
        pass

    def __rmult__(self, other): 
        '''__rmult__(self, other) -> MQuaternion
Returns: A reference to this quaternion which has been multiplied with the other quaternion 

Arguments:
	[in]	other = MQuaternion


The in place quaternion multiplication operator.'''
        pass

    def __mul__(self, other): 
        '''__mul__(self, other) -> MQuaternion
Returns: The product of the two quaternions 

Arguments:
	[in]	other = MQuaternion


This quaternion multiplication operator.'''
        pass

    def exp(self): 
        '''exp(self) -> MQuaternion


Exponentiates a quaternion that has a scalar part of zero. The precondition for using this method is that w is zero.'''
        pass

    def __sub__(self): 
        '''__sub__(self) -> MQuaternion


The unary minus operator. Negates the value of each of the x, y, z, and w components of the quaternion.'''
        pass

class MRampAttribute:
    '''Ramp data attribute function wrapper class. Function object for RampData attributes. A RampData attribute describes a ramp specified by a set of positions and values. Currently there is support for curve ramps and color ramps. '''
    def __init__(self):
        pass


    def addEntries(self, positions, values, interps): 
        '''addEntries(self, positions, values, interps)
Arguments:
	[in]	positions = MFloatArray
	[in]	values = MFloatArray
	[in]	interps = MIntArray


Adds entries into a ramp attribute. If the ramp is a color ramp, then this function will return a failure.'''
        pass

    def isColorRamp(self): 
        '''isColorRamp(self) -> bool
Returns: true if the ramp is a color ramp, false otherwise


Checks to see whether this ramp is a color ramp.'''
        pass

    def getEntries(self, indices, positions, colors, interps): 
        '''getEntries(self, indices, positions, colors, interps)
Arguments:
	[out]	indices = MIntArray
	[out]	positions = MFloatArray
	[out]	colors = MColorArray
	[out]	interps = MIntArray


Gets all the entries in a ramp attribute. If the ramp is a curve ramp, then this function will return a failure.'''
        pass

    def getColorAtPosition(self, position, color, context): 
        '''getColorAtPosition(self, position, color, context)
Arguments:
	[in]	position = float
	[out]	color = MColor
	[out]	context = MDGContext


Gets the color at a position'''
        pass

    def isCurveRamp(self): 
        '''isCurveRamp(self) -> bool
Returns: true if the ramp is a curve ramp, false otherwise


Checks to see whether this ramp is a curve ramp.'''
        pass

    def kNone(self):
        '''This is an enum of MInterpolation.
Description: 
Value: 1'''
        pass

    def kLinear(self):
        '''This is an enum of MInterpolation.
Description: 
Value: 0'''
        pass

    def kSmooth(self):
        '''This is an enum of MInterpolation.
Description: 
Value: 3'''
        pass

    def kSpline(self):
        '''This is an enum of MInterpolation.
Description: 
Value: 2'''
        pass

    class MInterpolation:
        '''Non-functional class.  Values for this enum:
        kNone
        kLinear
        kSmooth
        kSpline
'''
        def __init__(self):
            pass

    def setPositionAtIndex(self, position, index): 
        '''setPositionAtIndex(self, position, index)
Arguments:
	[in]	position = float
	[in]	index = int


Sets the position of a given entry'''
        pass

    def deleteEntries(self, indices): 
        '''deleteEntries(self, indices)
Arguments:
	[in]	indices = MIntArray


Deletes entries in the ramp attribute.'''
        pass

    def getNumEntries(self): 
        '''getNumEntries(self) -> int
Returns: The number of entries in the ramp attribute 


Gets the number of entries in the ramp attribute.'''
        pass

    def createCurveRamp(self, attrLongName, attrShortName): 
        '''createCurveRamp(self, attrLongName, attrShortName) -> MObject
Returns: Curve ramp attribute, returned as MObject.

Arguments:
	[in]	attrLongName = MString
	[in]	attrShortName = MString


This function creates the curve ramp attribute.'''
        pass

    def setInterpolationAtIndex(self, interp, index): 
        '''setInterpolationAtIndex(self, interp, index)
Arguments:
	[in]	interp = MRampAttribute.MInterpolation
	[in]	index = int


Sets the interpolation of a given entry'''
        pass

    def createColorRamp(self, attrLongName, attrShortName): 
        '''createColorRamp(self, attrLongName, attrShortName) -> MObject
Returns: Color ramp attribute, returned as MObject.

Arguments:
	[in]	attrLongName = MString
	[in]	attrShortName = MString


This function creates the color ramp attribute.'''
        pass

    def setValueAtIndex(self, value, index): 
        '''setValueAtIndex(self, value, index)
Arguments:
	[in]	value = float
	[in]	index = int


Sets the value of a given entry'''
        pass

    def getValueAtPosition(self, position, value, context): 
        '''getValueAtPosition(self, position, value, context)
Arguments:
	[in]	position = float
	[out]	value = float
	[out]	context = MDGContext


Gets the value at position'''
        pass

    def setColorAtIndex(self, color, index): 
        '''setColorAtIndex(self, color, index)
Arguments:
	[in]	color = MColor
	[in]	index = int


Sets the color of a given entry'''
        pass

class MRichSelection:
    '''Selection list supporting soft selection and symmetry. This class implements a selection list that support soft selection and symmetry.The rich selection is split into two halves: the "normal" side, and an optional symmetric component. Components on both sides can include weight data which is used to specify both the amount of influence and the proximity to the centre of symmetry.In addition to the selected objects, the rich selection also includes information about the axis of symmetry so that operations can determine how to process any symmetric selection (e.g. reflect transformations, etc). '''
    def __init__(self):
        pass


    def getSymmetryMatrix(self, path, space, symmetryMatrix): 
        '''getSymmetryMatrix(self, path, space, symmetryMatrix)
Arguments:
	[in]	path = MDagPath
	[in]	space = MSpace.Space
	[out]	symmetryMatrix = MMatrix


Returns the symmetry matrix to use for the symmetric component of the specified DAG object. This method handles any matrix space conversions for you.'''
        pass

    def getSymmetry(self, symmetry): 
        '''getSymmetry(self, symmetry)
Arguments:
	[out]	symmetry = MSelectionList


Returns a copy of the symmetry component of the rich selection.'''
        pass

    def getSelection(self, selection): 
        '''getSelection(self, selection)
Arguments:
	[out]	selection = MSelectionList


Returns a copy of the non-symmetry component of the rich selection.'''
        pass

    def getSymmetryPlane(self, path, space, symmetryPlane): 
        '''getSymmetryPlane(self, path, space, symmetryPlane)
Arguments:
	[in]	path = MDagPath
	[in]	space = MSpace.Space
	[out]	symmetryPlane = MPlane


Returns the plane of symmetry. This can be used to enforce seam weights in tools that support symmetry. Note that the direction of the plane carries no significance (specifically, having a positive offset from the plane does not imply a point is part of the non-symmetric selection).'''
        pass

    def clear(self): 
        '''clear(self)

This method empties the rich selection.'''
        pass

class MSceneMessage:
    '''Scene messages. This class is used to register callbacks for scene related messages.The addCallback method registers a function that will be executed whenever the specified message occurs. An id is returned and is used to remove the callback.To remove a callback use MMessage::removeCallback. All callbacks that are registered by a plug-in must be removed by that plug-in when it is unloaded. Failure to do so will result in a fatal error. '''
    def __init__(self):
        pass


    def addCheckFileCallback(self, msg, func, clientData): 
        '''addCheckFileCallback(self, msg, func, clientData) -> MCallbackId

Arguments:
	[in]	msg = MSceneMessage.Message
	[in]	func = MMessage.MCheckFileFunction
	[in]	clientData = void


This function adds a new callback for the specified scene message. This callback has the option to abort the current operation by setting the retCode parameter to false. The file parameter stores the target file for the current file IO operation, by modifying this file parameter the target file will be changed as well.'''
        pass

    def kBeforePluginLoad(self):
        '''This is an enum of Message.
Description: Called prior to a plugin being loaded.
Value: 37'''
        pass

    def kBeforeSoftwareRender(self):
        '''This is an enum of Message.
Description: Called before a Software Render begins.
Value: 21'''
        pass

    def kBeforeImportReference(self):
        '''This is an enum of Message.
Description: Called before a File > ImportReference operation.
Value: 15'''
        pass

    def kBeforeNewCheck(self):
        '''This is an enum of Message.
Description: Called prior to File > New operation, allows user to cancel action.
Value: 28'''
        pass

    def kBeforeReferenceCheck(self):
        '''This is an enum of Message.
Description: Called prior to a File > CreateReference operation, allows user to cancel action.
Value: 36'''
        pass

    def kBeforeExportReference(self):
        '''This is an enum of Message.
Description: Called before a File > ExportReference operation.
Value: 17'''
        pass

    def kBeforeSaveCheck(self):
        '''This is an enum of Message.
Description: Called prior to File > Save operation, allows user to cancel action.
Value: 30'''
        pass

    def kAfterPluginLoad(self):
        '''This is an enum of Message.
Description: Called after a plugin is loaded.
Value: 38'''
        pass

    def kBeforeUnloadReference(self):
        '''This is an enum of Message.
Description: Called before a File > UnloadReference operation.
Value: 19'''
        pass

    def kBeforeLoadReference(self):
        '''This is an enum of Message.
Description: Called before a File > LoadReference operation.
Value: 33'''
        pass

    def kAfterSoftwareFrameRender(self):
        '''This is an enum of Message.
Description: Called after each frame of a Software Render.
Value: 24'''
        pass

    def kAfterPluginUnload(self):
        '''This is an enum of Message.
Description: Called after a plugin is unloaded.
Value: 40'''
        pass

    def kAfterLoadReference(self):
        '''This is an enum of Message.
Description: Called after a File > LoadReference operation.
Value: 34'''
        pass

    def kBeforeReference(self):
        '''This is an enum of Message.
Description: Called before a File > Reference operation.
Value: 11'''
        pass

    def kBeforeSave(self):
        '''This is an enum of Message.
Description: Called before a File > Save (or SaveAs) operation.
Value: 9'''
        pass

    def kBeforeExportCheck(self):
        '''This is an enum of Message.
Description: Called prior to File > Export operation, allows user to cancel action.
Value: 32'''
        pass

    def kSoftwareRenderInterrupted(self):
        '''This is an enum of Message.
Description: Called when an interactive render is interrupted by the user.
Value: 25'''
        pass

    def kAfterOpen(self):
        '''This is an enum of Message.
Description: Called after a File > Open operation.
Value: 6'''
        pass

    def kAfterExportReference(self):
        '''This is an enum of Message.
Description: Called after a File > ExportReference operation.
Value: 18'''
        pass

    def kAfterReference(self):
        '''This is an enum of Message.
Description: Called after a File > Reference operation.
Value: 12'''
        pass

    def kAfterSave(self):
        '''This is an enum of Message.
Description: Called after a File > Save (or SaveAs) operation.
Value: 10'''
        pass

    def kBeforePluginUnload(self):
        '''This is an enum of Message.
Description: Called prior to a plugin being unloaded.
Value: 39'''
        pass

    def kBeforeLoadReferenceCheck(self):
        '''This is an enum of Message.
Description: Called before a File > LoadReference operation, allows user to cancel action.
Value: 35'''
        pass

    def kBeforeOpen(self):
        '''This is an enum of Message.
Description: Called before a File > Open operation.
Value: 5'''
        pass

    def kBeforeImport(self):
        '''This is an enum of Message.
Description: Called before a File > Import operation.
Value: 3'''
        pass

    def kMayaExiting(self):
        '''This is an enum of Message.
Description: Called just before Maya exits.
Value: 27'''
        pass

    def kBeforeSoftwareFrameRender(self):
        '''This is an enum of Message.
Description: Called before each frame of a Software Render.
Value: 23'''
        pass

    def kBeforeOpenCheck(self):
        '''This is an enum of Message.
Description: Called prior to File > Open operation, allows user to cancel action.
Value: 29'''
        pass

    def kAfterImportReference(self):
        '''This is an enum of Message.
Description: Called after a File > ImportReference operation.
Value: 16'''
        pass

    def kBeforeRemoveReference(self):
        '''This is an enum of Message.
Description: Called before a File > RemoveReference operation.
Value: 13'''
        pass

    def kAfterImport(self):
        '''This is an enum of Message.
Description: Called after a File > Import operation.
Value: 4'''
        pass

    def kLast(self):
        '''This is an enum of Message.
Description: Last value of the enum.
Value: 41'''
        pass

    def kAfterSoftwareRender(self):
        '''This is an enum of Message.
Description: Called after a Software Render ends.
Value: 22'''
        pass

    def kBeforeExport(self):
        '''This is an enum of Message.
Description: Called before a File > Export operation.
Value: 7'''
        pass

    def kAfterRemoveReference(self):
        '''This is an enum of Message.
Description: Called after a File > RemoveReference operation.
Value: 14'''
        pass

    def kSceneUpdate(self):
        '''This is an enum of Message.
Description: Called after any operation that changes which files are loaded.
Value: 0'''
        pass

    def kAfterExport(self):
        '''This is an enum of Message.
Description: Called after a File > Export operation.
Value: 8'''
        pass

    def kBeforeImportCheck(self):
        '''This is an enum of Message.
Description: Called prior to File > Import operation, allows user to cancel action.
Value: 31'''
        pass

    def kAfterNew(self):
        '''This is an enum of Message.
Description: Called after a File > New operation.
Value: 2'''
        pass

    def kBeforeNew(self):
        '''This is an enum of Message.
Description: Called before a File > New operation.
Value: 1'''
        pass

    def kAfterUnloadReference(self):
        '''This is an enum of Message.
Description: Called after a File > UnloadReference operation.
Value: 20'''
        pass

    def kMayaInitialized(self):
        '''This is an enum of Message.
Description: Called on interactive or batch startup after initialization.
Value: 26'''
        pass

    class Message:
        '''Non-functional class.  Values for this enum:
        kBeforePluginLoad
        kBeforeSoftwareRender
        kBeforeImportReference
        kBeforeNewCheck
        kBeforeReferenceCheck
        kBeforeExportReference
        kBeforeSaveCheck
        kAfterPluginLoad
        kBeforeUnloadReference
        kBeforeLoadReference
        kAfterSoftwareFrameRender
        kAfterPluginUnload
        kAfterLoadReference
        kBeforeReference
        kBeforeSave
        kBeforeExportCheck
        kSoftwareRenderInterrupted
        kAfterOpen
        kAfterExportReference
        kAfterReference
        kAfterSave
        kBeforePluginUnload
        kBeforeLoadReferenceCheck
        kBeforeOpen
        kBeforeImport
        kMayaExiting
        kBeforeSoftwareFrameRender
        kBeforeOpenCheck
        kAfterImportReference
        kBeforeRemoveReference
        kAfterImport
        kLast
        kAfterSoftwareRender
        kBeforeExport
        kAfterRemoveReference
        kSceneUpdate
        kAfterExport
        kBeforeImportCheck
        kAfterNew
        kBeforeNew
        kAfterUnloadReference
        kMayaInitialized
'''
        def __init__(self):
            pass

    def addCheckCallback(self, msg, func, clientData): 
        '''addCheckCallback(self, msg, func, clientData) -> MCallbackId

Arguments:
	[in]	msg = MSceneMessage.Message
	[in]	func = MMessage.MCheckFunction
	[in]	clientData = void


This function adds a new callback for the specified scene message and also has the option to abort the current operation by return false through the return code parameter.'''
        pass

    def addStringArrayCallback(self, msg, func, clientData): 
        '''addStringArrayCallback(self, msg, func, clientData) -> MCallbackId

Arguments:
	[in]	msg = MSceneMessage.Message
	[in]	func = MMessage.MStringArrayFunction
	[in]	clientData = void


Adds a new callback which takes a string array argument, in addition to the usual clientData.'''
        pass

    def addCallback(self, msg, func, clientData): 
        '''addCallback(self, msg, func, clientData) -> MCallbackId
Returns: Identifier used for removing the callback.

Arguments:
	[in]	msg = MSceneMessage.Message
	[in]	func = MMessage.MBasicFunction
	[in]	clientData = void


Adds a new callback for the specified scene message.'''
        pass

class MScriptUtil:
    '''Utility class for working with pointers and references. Utility class for working with pointers to basic types such as int, float and arrays of these types. Class is more applicable for script programming rather than C++. C++ pointers and references have no equivalent in script so this class provides utility methods for working with these type of parameters and return values.References are treated as pointers in script. This class allows creating data and then acquiring a pointer to the data so that information can be passed to class methods requiring references.Common scenarios:This class is cumbersome to use but it provides a way of building parameters and accessing return values for methods which would normally not be scriptable. '''
    def __init__(self):
        pass


    def setDoubleArray(self, index, value, var): 
        '''setDoubleArray(self, index, value, var) -> bool
Returns: True on success, false otherwise. 

Arguments:
	[out]	var = double
	[in]	index = int
	[in]	value = double


Set a double value in an array. Ensure that index is valid before calling this method.'''
        pass

    def asUint(self): 
        '''asUint(self) -> int

'''
        pass

    def createFromInt(self, x, y, z, w): 
        '''createFromInt(self, x, y, z, w)
Arguments:
	[in]	x = int
	[in]	y = int
	[in]	z = int
	[in]	w = int


Create this object from 4 integers. Data already stored in this class will be cleared.'''
        pass

    def getInt3ArrayItem(self, var, r, c): 
        '''getInt3ArrayItem(self, var, r, c) -> int
Returns: Value of the element: var[r][c] 

Arguments:
	[in]	var = int(*)3
	[in]	r = int
	[in]	c = int


Get a value from the three dimensional array. Ensure that indicies are valid before calling this method.'''
        pass

    def asShort(self): 
        '''asShort(self) -> short

'''
        pass

    def setCharArray(self, index, value, var): 
        '''setCharArray(self, index, value, var) -> bool
Returns: True on success, false otherwise. 

Arguments:
	[out]	var = char
	[in]	index = int
	[in]	value = int


Set a char value in an array. Ensure that index is valid before calling this method.'''
        pass

    def getUint4ArrayItem(self, var, r, c): 
        '''getUint4ArrayItem(self, var, r, c) -> int
Returns: Value of the element: var[r][c] 

Arguments:
	[in]	var = int(*)4
	[in]	r = int
	[in]	c = int


Get a value from the four dimensional array. Ensure that indicies are valid before calling this method.'''
        pass

    def getCharArrayItem(self, var, index): 
        '''getCharArrayItem(self, var, index) -> int
Returns: Value of the element. 

Arguments:
	[in]	var = char
	[in]	index = int


Get a char value from an array. Ensure that index is valid before calling this method.'''
        pass

    def getUint(self, var): 
        '''getUint(self, var) -> int

Arguments:
	[out]	var = int


Get the values of an unsigned int reference.  Parameters: 
 
 [in]   var   Reference to the variable to return.  
 
 
'''
        pass

    def setUint(self, value, var): 
        '''setUint(self, value, var)
Arguments:
	[out]	var = int
	[in]	value = int


Set an unsigned integer reference value.  Parameters: 
 
 [out]   var   Reference to the variable to be assigned.  
 [in]   value   Value to assign  
 
 
'''
        pass

    def asFloat(self): 
        '''asFloat(self) -> float

'''
        pass

    def setShortArray(self, index, value, var): 
        '''setShortArray(self, index, value, var) -> bool
Returns: True on success, false otherwise. 

Arguments:
	[out]	var = short
	[in]	index = int
	[in]	value = int


Set a short value in an array. Ensure that index is valid before calling this method.'''
        pass

    def asShortPtr(self): 
        '''asShortPtr(self) -> short*

'''
        pass

    def asInt2Ptr(self): 
        '''asInt2Ptr(self) -> MScriptUtil.Mint2*


Copy the data to a temporary array of the right type and return its address. Ensure that this object has been created with sufficient data.'''
        pass

    def setShort2ArrayItem(self, var, r, c, value): 
        '''setShort2ArrayItem(self, var, r, c, value) -> bool

Arguments:
	[in]	var = short(*)2
	[in]	r = int
	[in]	c = int
	[in]	value = short


Set a value in the two dimensional array. Ensure that indices are valid before calling this method.'''
        pass

    def asFloat4Ptr(self): 
        '''asFloat4Ptr(self) -> MScriptUtil.Mfloat4*


Copy the data to a temporary array of the right type and return its address. Ensure that this object has been created with sufficient data.'''
        pass

    def setFloat(self, value, var): 
        '''setFloat(self, value, var)
Arguments:
	[out]	var = float
	[in]	value = double


Set a float reference value.  Parameters: 
 
 [out]   var   Reference to the variable to be assigned.  
 [in]   value   Value to assign  
 
 
'''
        pass

    def setFloatArray(self, index, value, var): 
        '''setFloatArray(self, index, value, var) -> bool
Returns: True on success, false otherwise. 

Arguments:
	[out]	var = float
	[in]	index = int
	[in]	value = double


Set a float value in an array. Ensure that index is valid before calling this method.'''
        pass

    def asDouble(self): 
        '''asDouble(self) -> double

'''
        pass

    def asIntPtr(self): 
        '''asIntPtr(self) -> int*

'''
        pass

    def setUchar(self, value, var): 
        '''setUchar(self, value, var)
Arguments:
	[out]	var = char
	[in]	value = int


Set an unsigned char reference value.  Parameters: 
 
 [out]   var   Reference to the variable to be assigned.  
 [in]   value   Value to assign  
 
 
'''
        pass

    def asFloat3Ptr(self): 
        '''asFloat3Ptr(self) -> MScriptUtil.Mfloat3*


Copy the data to a temporary array of the right type and return its address. Ensure that this object has been created with sufficient data.'''
        pass

    def asUint2Ptr(self): 
        '''asUint2Ptr(self) -> MScriptUtil.Muint2*


Copy the data to a temporary array of the right type and return its address. Ensure that this object has been created with sufficient data.'''
        pass

    def setBool(self, value, var): 
        '''setBool(self, value, var)
Arguments:
	[out]	var = bool
	[in]	value = int


Set a bool reference value.  Parameters: 
 
 [out]   var   Reference to the variable to be assigned.  
 [in]   value   Value to assign  
 
 
'''
        pass

    def setFloat2ArrayItem(self, var, r, c, value): 
        '''setFloat2ArrayItem(self, var, r, c, value) -> bool

Arguments:
	[in]	var = float(*)2
	[in]	r = int
	[in]	c = int
	[in]	value = float


Set a value in the two dimensional array. Ensure that indices are valid before calling this method.'''
        pass

    def getFloatArrayItem(self, var, index): 
        '''getFloatArrayItem(self, var, index) -> double
Returns: Value of the element. 

Arguments:
	[in]	var = float
	[in]	index = int


Get a float value from an array. Ensure that index is valid before calling this method.'''
        pass

    def setUintArray(self, index, value, var): 
        '''setUintArray(self, index, value, var) -> bool
Returns: True on success, false otherwise. 

Arguments:
	[out]	var = int
	[in]	index = int
	[in]	value = int


Set an unsigned integer value in an array. Ensure that index is valid before calling this method.'''
        pass

    def getUint3ArrayItem(self, var, r, c): 
        '''getUint3ArrayItem(self, var, r, c) -> int
Returns: Value of the element: var[r][c] 

Arguments:
	[in]	var = int(*)3
	[in]	r = int
	[in]	c = int


Get a value from the three dimensional array. Ensure that indicies are valid before calling this method.'''
        pass

    def getShortArrayItem(self, var, index): 
        '''getShortArrayItem(self, var, index) -> int
Returns: Value of the element. 

Arguments:
	[in]	var = short
	[in]	index = int


Get a short value from an array. Ensure that index is valid before calling this method.'''
        pass

    def setDouble3ArrayItem(self, var, r, c, value): 
        '''setDouble3ArrayItem(self, var, r, c, value) -> bool

Arguments:
	[in]	var = double(*)3
	[in]	r = int
	[in]	c = int
	[in]	value = double


Set a value in the three dimensional array. Ensure that indices are valid before calling this method.'''
        pass

    def asCharPtr(self): 
        '''asCharPtr(self) -> char*

'''
        pass

    def getDouble2ArrayItem(self, var, r, c): 
        '''getDouble2ArrayItem(self, var, r, c) -> double
Returns: Value of the element: var[r][c] 

Arguments:
	[in]	var = double(*)2
	[in]	r = int
	[in]	c = int


Get a value from the two dimensional array. Ensure that indicies are valid before calling this method.'''
        pass

    def getFloat4ArrayItem(self, var, r, c): 
        '''getFloat4ArrayItem(self, var, r, c) -> float
Returns: Value of the element: var[r][c] 

Arguments:
	[in]	var = float(*)4
	[in]	r = int
	[in]	c = int


Get a value from the four dimensional array. Ensure that indicies are valid before calling this method.'''
        pass

    def setInt2ArrayItem(self, var, r, c, value): 
        '''setInt2ArrayItem(self, var, r, c, value) -> bool

Arguments:
	[in]	var = int(*)2
	[in]	r = int
	[in]	c = int
	[in]	value = int


Set a value in the two dimensional array. Ensure that indices are valid before calling this method.'''
        pass

    def getUintArrayItem(self, var, index): 
        '''getUintArrayItem(self, var, index) -> int
Returns: Value of the element. 

Arguments:
	[in]	var = int
	[in]	index = int


Get an unsigned value from an array. Ensure that index is valid before calling this method.'''
        pass

    def setInt3ArrayItem(self, var, r, c, value): 
        '''setInt3ArrayItem(self, var, r, c, value) -> bool

Arguments:
	[in]	var = int(*)3
	[in]	r = int
	[in]	c = int
	[in]	value = int


Set a value in the three dimensional array. Ensure that indices are valid before calling this method.'''
        pass

    def getDouble3ArrayItem(self, var, r, c): 
        '''getDouble3ArrayItem(self, var, r, c) -> double
Returns: Value of the element: var[r][c] 

Arguments:
	[in]	var = double(*)3
	[in]	r = int
	[in]	c = int


Get a value from the three dimensional array. Ensure that indicies are valid before calling this method.'''
        pass

    def getInt4ArrayItem(self, var, r, c): 
        '''getInt4ArrayItem(self, var, r, c) -> int
Returns: Value of the element: var[r][c] 

Arguments:
	[in]	var = int(*)4
	[in]	r = int
	[in]	c = int


Get a value from the four dimensional array. Ensure that indicies are valid before calling this method.'''
        pass

    def getShort4ArrayItem(self, var, r, c): 
        '''getShort4ArrayItem(self, var, r, c) -> short
Returns: Value of the element: var[r][c] 

Arguments:
	[in]	var = short(*)4
	[in]	r = int
	[in]	c = int


Get a value from the four dimensional array. Ensure that indicies are valid before calling this method.'''
        pass

    def asDoublePtr(self): 
        '''asDoublePtr(self) -> double*

'''
        pass

    def getFloat(self, var): 
        '''getFloat(self, var) -> double

Arguments:
	[out]	var = float


Get the values of a float reference.  Parameters: 
 
 [in]   var   Reference to the variable to return.  
 
 
'''
        pass

    def getBoolArrayItem(self, var, index): 
        '''getBoolArrayItem(self, var, index) -> int
Returns: Value of the element. 

Arguments:
	[in]	var = bool
	[in]	index = int


Get a bool value from an array. Ensure that index is valid before calling this method.'''
        pass

    def asUintPtr(self): 
        '''asUintPtr(self) -> int*

'''
        pass

    def setUint4ArrayItem(self, var, r, c, value): 
        '''setUint4ArrayItem(self, var, r, c, value) -> bool

Arguments:
	[in]	var = int(*)4
	[in]	r = int
	[in]	c = int
	[in]	value = int


Set a value in the four dimensional array. Ensure that indices are valid before calling this method.'''
        pass

    def setShort4ArrayItem(self, var, r, c, value): 
        '''setShort4ArrayItem(self, var, r, c, value) -> bool

Arguments:
	[in]	var = short(*)4
	[in]	r = int
	[in]	c = int
	[in]	value = short


Set a value in the two dimensional array. Ensure that indices are valid before calling this method.'''
        pass

    def asInt4Ptr(self): 
        '''asInt4Ptr(self) -> MScriptUtil.Mint4*


Copy the data to a temporary array of the right type and return its address. Ensure that this object has been created with sufficient data.'''
        pass

    def getUcharArrayItem(self, var, index): 
        '''getUcharArrayItem(self, var, index) -> int
Returns: Value of the element. 

Arguments:
	[in]	var = char
	[in]	index = int


Get an unsigned char value from an array. Ensure that index is valid before calling this method.'''
        pass

    def asUint3Ptr(self): 
        '''asUint3Ptr(self) -> MScriptUtil.Muint3*


Copy the data to a temporary array of the right type and return its address. Ensure that this object has been created with sufficient data.'''
        pass

    def setDouble4ArrayItem(self, var, r, c, value): 
        '''setDouble4ArrayItem(self, var, r, c, value) -> bool

Arguments:
	[in]	var = double(*)4
	[in]	r = int
	[in]	c = int
	[in]	value = double


Set a value in the four dimensional array. Ensure that indices are valid before calling this method.'''
        pass

    def setInt4ArrayItem(self, var, r, c, value): 
        '''setInt4ArrayItem(self, var, r, c, value) -> bool

Arguments:
	[in]	var = int(*)4
	[in]	r = int
	[in]	c = int
	[in]	value = int


Set a value in the four dimensional array. Ensure that indices are valid before calling this method.'''
        pass

    def getDouble4ArrayItem(self, var, r, c): 
        '''getDouble4ArrayItem(self, var, r, c) -> double
Returns: Value of the element: var[r][c] 

Arguments:
	[in]	var = double(*)4
	[in]	r = int
	[in]	c = int


Get a value from the four dimensional array. Ensure that indicies are valid before calling this method.'''
        pass

    def getBool(self, var): 
        '''getBool(self, var) -> int

Arguments:
	[in]	var = bool

'''
        pass

    def asShort3Ptr(self): 
        '''asShort3Ptr(self) -> MScriptUtil.Mshort3*


Copy the data to a temporary array of the right type and return its address. Ensure that this object has been created with sufficient data.'''
        pass

    def getInt(self, var): 
        '''getInt(self, var) -> int

Arguments:
	[out]	var = int


Get the value of an integer reference.  Parameters: 
 
 [in]   var   Reference to the variable to return.  
 
 
'''
        pass

    def getShort3ArrayItem(self, var, r, c): 
        '''getShort3ArrayItem(self, var, r, c) -> short
Returns: Value of the element: var[r][c] 

Arguments:
	[in]	var = short(*)3
	[in]	r = int
	[in]	c = int


Get a value from the three dimensional array. Ensure that indicies are valid before calling this method.'''
        pass

    def getFloat3ArrayItem(self, var, r, c): 
        '''getFloat3ArrayItem(self, var, r, c) -> float
Returns: Value of the element: var[r][c] 

Arguments:
	[in]	var = float(*)3
	[in]	r = int
	[in]	c = int


Get a value from the three dimensional array. Ensure that indicies are valid before calling this method.'''
        pass

    def getDouble(self, var): 
        '''getDouble(self, var) -> double

Arguments:
	[out]	var = double


Get the value of a double reference.  Parameters: 
 
 [in]   var   Reference to the variable to return.  
 
 
'''
        pass

    def setDouble(self, value, var): 
        '''setDouble(self, value, var)
Arguments:
	[out]	var = double
	[in]	value = double


Set a double reference value.  Parameters: 
 
 [out]   var   Reference to the variable to be assigned.  
 [in]   value   Value to assign  
 
 
'''
        pass

    def setInt(self, value, var): 
        '''setInt(self, value, var)
Arguments:
	[out]	var = int
	[in]	value = int


Set an integer reference value.  Parameters: 
 
 [out]   var   Reference to the variable to be assigned.  
 [in]   value   Value to assign  
 
 
'''
        pass

    def asFloat2Ptr(self): 
        '''asFloat2Ptr(self) -> MScriptUtil.Mfloat2*


Copy the data to a temporary array of the right type and return its address. Ensure that this object has been created with sufficient data.'''
        pass

    def asInt(self): 
        '''asInt(self) -> int

'''
        pass

    def getChar(self, var): 
        '''getChar(self, var) -> int

Arguments:
	[in]	var = char


Get the value of a char reference.  Parameters: 
 
 [in]   var   Reference to the variable to return.  
 
 
'''
        pass

    def asDouble4Ptr(self): 
        '''asDouble4Ptr(self) -> MScriptUtil.Mdouble4*


Copy the data to a temporary array of the right type and return its address. Ensure that this object has been created with sufficient data.'''
        pass

    def getUchar(self, var): 
        '''getUchar(self, var) -> int

Arguments:
	[in]	var = char


Get the value of an unsigned char reference.  Parameters: 
 
 [in]   var   Reference to the variable to return.  
 
 
'''
        pass

    def setFloat3ArrayItem(self, var, r, c, value): 
        '''setFloat3ArrayItem(self, var, r, c, value) -> bool

Arguments:
	[in]	var = float(*)3
	[in]	r = int
	[in]	c = int
	[in]	value = float


Set a value in the three dimensional array. Ensure that indices are valid before calling this method.'''
        pass

    def setUcharArray(self, index, value, var): 
        '''setUcharArray(self, index, value, var) -> bool
Returns: True on success, false otherwise. 

Arguments:
	[out]	var = char
	[in]	index = int
	[in]	value = int


Set an unsigned char value in an array. Ensure that index is valid before calling this method.'''
        pass

    def setFloat4ArrayItem(self, var, r, c, value): 
        '''setFloat4ArrayItem(self, var, r, c, value) -> bool

Arguments:
	[in]	var = float(*)4
	[in]	r = int
	[in]	c = int
	[in]	value = float


Set a value in the four dimensional array. Ensure that indices are valid before calling this method.'''
        pass

    def asBoolPtr(self): 
        '''asBoolPtr(self) -> bool*

'''
        pass

    def asInt3Ptr(self): 
        '''asInt3Ptr(self) -> MScriptUtil.Mint3*


Copy the data to a temporary array of the right type and return its address. Ensure that this object has been created with sufficient data.'''
        pass

    def getShort(self, var): 
        '''getShort(self, var) -> int

Arguments:
	[in]	var = short


Get the value of a short reference.  Parameters: 
 
 [in]   var   Reference to the variable to return.  
 
 
'''
        pass

    def getFloat2ArrayItem(self, var, r, c): 
        '''getFloat2ArrayItem(self, var, r, c) -> float
Returns: Value of the element: var[r][c] 

Arguments:
	[in]	var = float(*)2
	[in]	r = int
	[in]	c = int


Get a value from the two dimensional array. Ensure that indicies are valid before calling this method.'''
        pass

    def asShort2Ptr(self): 
        '''asShort2Ptr(self) -> MScriptUtil.Mshort2*


Copy the data to a temporary array of the right type and return its address. Ensure that this object has been created with sufficient data.'''
        pass

    def asFloatPtr(self): 
        '''asFloatPtr(self) -> float*

'''
        pass

    def asDouble3Ptr(self): 
        '''asDouble3Ptr(self) -> MScriptUtil.Mdouble3*


Copy the data to a temporary array of the right type and return its address. Ensure that this object has been created with sufficient data.'''
        pass

    def asUint4Ptr(self): 
        '''asUint4Ptr(self) -> MScriptUtil.Muint4*


Copy the data to a temporary array of the right type and return its address. Ensure that this object has been created with sufficient data.'''
        pass

    def setUint3ArrayItem(self, var, r, c, value): 
        '''setUint3ArrayItem(self, var, r, c, value) -> bool

Arguments:
	[in]	var = int(*)3
	[in]	r = int
	[in]	c = int
	[in]	value = int


Set a value in the three dimensional array. Ensure that indices are valid before calling this method.'''
        pass

    def asDouble2Ptr(self): 
        '''asDouble2Ptr(self) -> MScriptUtil.Mdouble2*


Copy the data to a temporary array of the right type and return its address. Ensure that this object has been created with sufficient data.'''
        pass

    def getDoubleArrayItem(self, var, index): 
        '''getDoubleArrayItem(self, var, index) -> double
Returns: Value of the element. 

Arguments:
	[in]	var = double
	[in]	index = int


Get a double value from an array. Ensure that index is valid before calling this method.'''
        pass

    def setBoolArray(self, index, value, var): 
        '''setBoolArray(self, index, value, var) -> bool
Returns: True on success, false otherwise. 

Arguments:
	[out]	var = bool
	[in]	index = int
	[in]	value = int


Set a bool value in an array. Ensure that index is valid before calling this method.'''
        pass

    def getUint2ArrayItem(self, var, r, c): 
        '''getUint2ArrayItem(self, var, r, c) -> int
Returns: Value of the element: var[r][c] 

Arguments:
	[in]	var = int(*)2
	[in]	r = int
	[in]	c = int


Get a value from the two dimensional array. Ensure that indicies are valid before calling this method.'''
        pass

    def setShort(self, value, var): 
        '''setShort(self, value, var)
Arguments:
	[out]	var = short
	[in]	value = int


Set a short reference value.  Parameters: 
 
 [out]   var   Reference to the variable to be assigned.  
 [in]   value   Value to assign  
 
 
'''
        pass

    def setIntArray(self, index, value, var): 
        '''setIntArray(self, index, value, var) -> bool
Returns: True on success, false otherwise. 

Arguments:
	[out]	var = int
	[in]	index = int
	[in]	value = int


Set an integer value in an array. Ensure that index is valid before calling this method.'''
        pass

    def getIntArrayItem(self, var, index): 
        '''getIntArrayItem(self, var, index) -> int
Returns: Value of the element. 

Arguments:
	[in]	var = int
	[in]	index = int


Get a int value from an array. Ensure that index is valid before calling this method.'''
        pass

    def getShort2ArrayItem(self, var, r, c): 
        '''getShort2ArrayItem(self, var, r, c) -> short
Returns: Value of the element: var[r][c] 

Arguments:
	[in]	var = short(*)2
	[in]	r = int
	[in]	c = int


Get a value from the two dimensional array. Ensure that indicies are valid before calling this method.'''
        pass

    def asShort4Ptr(self): 
        '''asShort4Ptr(self) -> MScriptUtil.Mshort4*


Copy the data to a temporary array of the right type and return its address. Ensure that this object has been created with sufficient data.'''
        pass

    def asBool(self): 
        '''asBool(self) -> bool

'''
        pass

    def getInt2ArrayItem(self, var, r, c): 
        '''getInt2ArrayItem(self, var, r, c) -> int
Returns: Value of the element: var[r][c] 

Arguments:
	[in]	var = int(*)2
	[in]	r = int
	[in]	c = int


Get a value from the two dimensional array. Ensure that indicies are valid before calling this method.'''
        pass

    def createFromDouble(self, x, y, z, w): 
        '''createFromDouble(self, x, y, z, w)
Arguments:
	[in]	x = double
	[in]	y = double
	[in]	z = double
	[in]	w = double


Create this object from 4 doubles. Data already stored in this class will be cleared.'''
        pass

    def setDouble2ArrayItem(self, var, r, c, value): 
        '''setDouble2ArrayItem(self, var, r, c, value) -> bool

Arguments:
	[in]	var = double(*)2
	[in]	r = int
	[in]	c = int
	[in]	value = double


Set a value in the two dimensional array. Ensure that indices are valid before calling this method.'''
        pass

    def setChar(self, value, var): 
        '''setChar(self, value, var)
Arguments:
	[out]	var = char
	[in]	value = int


Set a char reference value.  Parameters: 
 
 [out]   var   Reference to the variable to be assigned.  
 [in]   value   Value to assign  
 
 
'''
        pass

    def setUint2ArrayItem(self, var, r, c, value): 
        '''setUint2ArrayItem(self, var, r, c, value) -> bool

Arguments:
	[in]	var = int(*)2
	[in]	r = int
	[in]	c = int
	[in]	value = int


Set a value in the two dimensional array. Ensure that indices are valid before calling this method.'''
        pass

    def asUcharPtr(self): 
        '''asUcharPtr(self) -> char*

'''
        pass

    def setShort3ArrayItem(self, var, r, c, value): 
        '''setShort3ArrayItem(self, var, r, c, value) -> bool

Arguments:
	[in]	var = short(*)3
	[in]	r = int
	[in]	c = int
	[in]	value = short


Set a value in the three dimensional array. Ensure that indices are valid before calling this method.'''
        pass

class MSelectionList:
    '''A list of MObjects. This class implements a list of MObjects.The global selection list is a special case where the objects on the list are also active objects in Maya.Besides the usual list methods, this class also provides an add method which retrieves objects from Maya, such as dependency nodes, by name. '''
    def __init__(self):
        pass


    def toggle(self, item, component): 
        '''toggle(self, item, component)
Arguments:
	[in]	item = MDagPath
	[in]	component = MObject


Removes those components of the given selection item which are on the selection list, and adds those parts which are not. This method does nothing if no components are provided.'''
        pass

    def getSelectionStrings(self, index, array): 
        '''getSelectionStrings(self, index, array)
Arguments:
	[in]	index = int
	[out]	array = MStringArray


Gets the string representation of the given item in the selection list. The strings will be in the format used by the scripting language. More than one string will be returned in the case that the item in the selection list has a component that that contains elements that are not contiguous (eg CV's 2 and 8 are selected on a surface).'''
        pass

    def hasItemPartly(self, item, component): 
        '''hasItemPartly(self, item, component) -> bool
Returns: true if at least one of the components in this list, false otherwise

Arguments:
	[in]	item = MDagPath
	[in]	component = MObject


This method differs from  hasItem  in that it determines whether or not  at least one  of the components of the the given DAG object are in this selection list. This method is only applicable when multiple components are provided.'''
        pass

    def clear(self): 
        '''clear(self)

This method empties the selection list.'''
        pass

    def getDagPath(self, index, dagPath, component): 
        '''getDagPath(self, index, dagPath, component)
Arguments:
	[in]	index = int
	[out]	dagPath = MDagPath
	[out]	component = MObject


Get the dag path and component (may be NULL) of the given element of the selection list.'''
        pass

    def add(self, plug, mergeWithExisting): 
        '''add(self, plug, mergeWithExisting)
Arguments:
	[in]	plug = MPlug
	[in]	mergeWithExisting = bool


Add the specified plug to the selection list.'''
        pass

    def remove(self, index): 
        '''remove(self, index)
Arguments:
	[in]	index = int


Removes the item at the given index from the list.'''
        pass

    def replace(self, index, plug): 
        '''replace(self, index, plug)
Arguments:
	[in]	index = int
	[in]	plug = MPlug


Remove the item at the given index in the list and replace it with the given plug. The given index must not be greater than the current number of items on the list.'''
        pass

    def merge(self, item, component, strategy): 
        '''merge(self, item, component, strategy)
Arguments:
	[in]	item = MDagPath
	[in]	component = MObject
	[in]	strategy = MSelectionList.MergeStrategy


Merge the given DAG object into the selection list.'''
        pass

    def length(self): 
        '''length(self) -> int
Returns: Number of items in the list


This method returns the number of selection items in the list.'''
        pass

    def isEmpty(self): 
        '''isEmpty(self) -> bool
Returns: true if the list is empty, false otherwise.


Specifies whether or not the selection list contains any items.'''
        pass

    def kMergeNormal(self):
        '''This is an enum of MergeStrategy.
Description: If the object is not already on the list, add it.
Value: 0'''
        pass

    def kRemoveFromList(self):
        '''This is an enum of MergeStrategy.
Description: Remove the object from the list.
Value: 2'''
        pass

    def kXORWithList(self):
        '''This is an enum of MergeStrategy.
Description: Exclusive OR: if the object is already on the list, remove it, otherwise add it.
Value: 1'''
        pass

    class MergeStrategy:
        '''Non-functional class.  Values for this enum:
        kMergeNormal
        kRemoveFromList
        kXORWithList
'''
        def __init__(self):
            pass

    def getPlug(self, index, plug): 
        '''getPlug(self, index, plug)
Arguments:
	[in]	index = int
	[out]	plug = MPlug


Get the plug at the specified index of the selection list.'''
        pass

    def hasItem(self, plug): 
        '''hasItem(self, plug) -> bool
Returns: true if the plug is in this list, false otherwise

Arguments:
	[in]	plug = MPlug


Determines whether or not the given plug is in this selection list.'''
        pass

    def getDependNode(self, index, depNode): 
        '''getDependNode(self, index, depNode)
Arguments:
	[in]	index = int
	[out]	depNode = MObject


Get a handle for the dependency node of the given element of the selection list.'''
        pass

class MSelectionMask:
    '''Manage what is selectable in Maya. (OpenMaya) (OpenMaya.py). Selection masks provide a way to control what is selectable in Maya.Selection masks can be created by OR'ing several types together, or by using the addMask method to add a selection type to an MSelectionMask.Example - to set the object selection mask to nurbsSurfaces, nurbsCurves, cameras, and lights'''
    def __init__(self):
        pass


    def addMask(self, selType): 
        '''addMask(self, selType)
Arguments:
	[in]	selType = MSelectionMask.SelectionType


Add the specified selection type to this mask.'''
        pass

    def setMask(self, mask): 
        '''setMask(self, mask)
Arguments:
	[in]	mask = MSelectionMask


Sets the selection type for this mask to the selection type of the specified mask.'''
        pass

    def intersects(self, mask): 
        '''intersects(self, mask) -> bool
Returns: true the specified selectin mask is contained in this mask 
false the specified selectin mask is not in this mask

Arguments:
	[in]	mask = MSelectionMask


Returns true if the specified selection mask is contained within this selection mask.'''
        pass

    def kSelectMeshVerts(self):
        '''This is an enum of SelectionType.
Description: 
Value: 33'''
        pass

    def kSelectMeshFaces(self):
        '''This is an enum of SelectionType.
Description: 
Value: 36'''
        pass

    def kSelectSubdivMeshMaps(self):
        '''This is an enum of SelectionType.
Description: 
Value: 76'''
        pass

    def kSelectOrientationLocators(self):
        '''This is an enum of SelectionType.
Description: 
Value: 23'''
        pass

    def kSelectCollisionModels(self):
        '''This is an enum of SelectionType.
Description: 
Value: 21'''
        pass

    def kSelectComponentsMask(self):
        '''This is an enum of SelectionType.
Description: 
Value: 62'''
        pass

    def kSelectMeshComponents(self):
        '''This is an enum of SelectionType.
Description: 
Value: 45'''
        pass

    def kSelectNRigids(self):
        '''This is an enum of SelectionType.
Description: 
Value: 81'''
        pass

    def kSelectRigidConstraints(self):
        '''This is an enum of SelectionType.
Description: 
Value: 20'''
        pass

    def kSelectCurveKnots(self):
        '''This is an enum of SelectionType.
Description: 
Value: 47'''
        pass

    def kSelectEmitters(self):
        '''This is an enum of SelectionType.
Description: 
Value: 16'''
        pass

    def kSelectAnimKeyframes(self):
        '''This is an enum of SelectionType.
Description: 
Value: 64'''
        pass

    def kSelectTemplates(self):
        '''This is an enum of SelectionType.
Description: 
Value: 69'''
        pass

    def kSelectPointsOnCurvesForGravity(self):
        '''This is an enum of SelectionType.
Description: 
Value: 73'''
        pass

    def kSelectIsoparms(self):
        '''This is an enum of SelectionType.
Description: 
Value: 52'''
        pass

    def kSelectJoints(self):
        '''This is an enum of SelectionType.
Description: 
Value: 4'''
        pass

    def kSelectMeshLines(self):
        '''This is an enum of SelectionType.
Description: 
Value: 44'''
        pass

    def kSelectParticles(self):
        '''This is an enum of SelectionType.
Description: 
Value: 56'''
        pass

    def kSelectTextures(self):
        '''This is an enum of SelectionType.
Description: 
Value: 25'''
        pass

    def kSelectSurfaceRange(self):
        '''This is an enum of SelectionType.
Description: 
Value: 50'''
        pass

    def kSelectObjectsMask(self):
        '''This is an enum of SelectionType.
Description: 
Value: 29'''
        pass

    def kSelectIkHandles(self):
        '''This is an enum of SelectionType.
Description: 
Value: 2'''
        pass

    def kSelectSketchPlanes(self):
        '''This is an enum of SelectionType.
Description: 
Value: 14'''
        pass

    def kSelectLocalAxis(self):
        '''This is an enum of SelectionType.
Description: 
Value: 1'''
        pass

    def kSelectSubdivMeshPoints(self):
        '''This is an enum of SelectionType.
Description: 
Value: 37'''
        pass

    def kSelectParticleShapes(self):
        '''This is an enum of SelectionType.
Description: 
Value: 15'''
        pass

    def kSelectDynamicConstraints(self):
        '''This is an enum of SelectionType.
Description: 
Value: 82'''
        pass

    def kSelectAnimAny(self):
        '''This is an enum of SelectionType.
Description: 
Value: 68'''
        pass

    def kSelectMeshUVs(self):
        '''This is an enum of SelectionType.
Description: 
Value: 40'''
        pass

    def kSelectFacets(self):
        '''This is an enum of SelectionType.
Description: 
Value: 43'''
        pass

    def kSelectGuideLines(self):
        '''This is an enum of SelectionType.
Description: 
Value: 71'''
        pass

    def kSelectHairSystems(self):
        '''This is an enum of SelectionType.
Description: 
Value: 78'''
        pass

    def kSelectFields(self):
        '''This is an enum of SelectionType.
Description: 
Value: 17'''
        pass

    def kSelectLights(self):
        '''This is an enum of SelectionType.
Description: 
Value: 5'''
        pass

    def kSelectCVs(self):
        '''This is an enum of SelectionType.
Description: 
Value: 30'''
        pass

    def kSelectManipulators(self):
        '''This is an enum of SelectionType.
Description: 
Value: 70'''
        pass

    def kSelectPivots(self):
        '''This is an enum of SelectionType.
Description: 
Value: 60'''
        pass

    def kSelectCurves(self):
        '''This is an enum of SelectionType.
Description: 
Value: 26'''
        pass

    def kSelectObjectGroups(self):
        '''This is an enum of SelectionType.
Description: 
Value: 75'''
        pass

    def kSelectSurfaces(self):
        '''This is an enum of SelectionType.
Description: 
Value: 27'''
        pass

    def kSelectLattices(self):
        '''This is an enum of SelectionType.
Description: 
Value: 7'''
        pass

    def kSelectXYZLocators(self):
        '''This is an enum of SelectionType.
Description: 
Value: 22'''
        pass

    def kSelectCameras(self):
        '''This is an enum of SelectionType.
Description: 
Value: 6'''
        pass

    def kSelectJointPivots(self):
        '''This is an enum of SelectionType.
Description: 
Value: 57'''
        pass

    def kSelectCurveParmPoints(self):
        '''This is an enum of SelectionType.
Description: 
Value: 46'''
        pass

    def kSelectNurbsSurfaces(self):
        '''This is an enum of SelectionType.
Description: 
Value: 11'''
        pass

    def kSelectSurfaceKnots(self):
        '''This is an enum of SelectionType.
Description: 
Value: 49'''
        pass

    def kSelectUVLocators(self):
        '''This is an enum of SelectionType.
Description: 
Value: 24'''
        pass

    def kSelectSurfaceParmPoints(self):
        '''This is an enum of SelectionType.
Description: 
Value: 48'''
        pass

    def kSelectSelectHandles(self):
        '''This is an enum of SelectionType.
Description: 
Value: 61'''
        pass

    def kSelectPointsForGravity(self):
        '''This is an enum of SelectionType.
Description: 
Value: 72'''
        pass

    def kSelectNurbsCurves(self):
        '''This is an enum of SelectionType.
Description: 
Value: 10'''
        pass

    def kSelectPPStrokes(self):
        '''This is an enum of SelectionType.
Description: 
Value: 54'''
        pass

    def kSelectMeshes(self):
        '''This is an enum of SelectionType.
Description: 
Value: 12'''
        pass

    def kSelectSubdivMeshEdges(self):
        '''This is an enum of SelectionType.
Description: 
Value: 38'''
        pass

    def kSelectNCloths(self):
        '''This is an enum of SelectionType.
Description: 
Value: 80'''
        pass

    def kSelectClusters(self):
        '''This is an enum of SelectionType.
Description: 
Value: 8'''
        pass

    def kSelectRigidBodies(self):
        '''This is an enum of SelectionType.
Description: 
Value: 19'''
        pass

    def kSelectVertices(self):
        '''This is an enum of SelectionType.
Description: 
Value: 41'''
        pass

    def kSelectSubdiv(self):
        '''This is an enum of SelectionType.
Description: 
Value: 13'''
        pass

    def kSelectFluids(self):
        '''This is an enum of SelectionType.
Description: 
Value: 77'''
        pass

    def kSelectSprings(self):
        '''This is an enum of SelectionType.
Description: 
Value: 18'''
        pass

    def kSelectScalePivots(self):
        '''This is an enum of SelectionType.
Description: 
Value: 58'''
        pass

    def kSelectMeshFreeEdges(self):
        '''This is an enum of SelectionType.
Description: 
Value: 35'''
        pass

    def kSelectAnimInTangents(self):
        '''This is an enum of SelectionType.
Description: 
Value: 65'''
        pass

    def kSelectAnimMask(self):
        '''This is an enum of SelectionType.
Description: 
Value: 67'''
        pass

    def kSelectFollicles(self):
        '''This is an enum of SelectionType.
Description: 
Value: 79'''
        pass

    def kSelectMeshEdges(self):
        '''This is an enum of SelectionType.
Description: 
Value: 34'''
        pass

    def kSelectSculpts(self):
        '''This is an enum of SelectionType.
Description: 
Value: 9'''
        pass

    def kSelectHandles(self):
        '''This is an enum of SelectionType.
Description: 
Value: 0'''
        pass

    def kSelectEditPoints(self):
        '''This is an enum of SelectionType.
Description: 
Value: 32'''
        pass

    def kSelectIkEndEffectors(self):
        '''This is an enum of SelectionType.
Description: 
Value: 3'''
        pass

    def kSelectNParticles(self):
        '''This is an enum of SelectionType.
Description: 
Value: 83'''
        pass

    def kSelectPointsOnSurfacesForGravity(self):
        '''This is an enum of SelectionType.
Description: 
Value: 74'''
        pass

    def kSelectHulls(self):
        '''This is an enum of SelectionType.
Description: 
Value: 31'''
        pass

    def kSelectSurfaceEdge(self):
        '''This is an enum of SelectionType.
Description: 
Value: 51'''
        pass

    def kSelectCurvesOnSurfaces(self):
        '''This is an enum of SelectionType.
Description: 
Value: 53'''
        pass

    def kSelectAnimOutTangents(self):
        '''This is an enum of SelectionType.
Description: 
Value: 66'''
        pass

    def kSelectSubdivMeshFaces(self):
        '''This is an enum of SelectionType.
Description: 
Value: 39'''
        pass

    def kSelectLatticePoints(self):
        '''This is an enum of SelectionType.
Description: 
Value: 55'''
        pass

    def kSelectRotatePivots(self):
        '''This is an enum of SelectionType.
Description: 
Value: 59'''
        pass

    def kSelectEdges(self):
        '''This is an enum of SelectionType.
Description: 
Value: 42'''
        pass

    def kSelectAnimCurves(self):
        '''This is an enum of SelectionType.
Description: 
Value: 63'''
        pass

    def kSelectLocators(self):
        '''This is an enum of SelectionType.
Description: 
Value: 28'''
        pass

    class SelectionType:
        '''Non-functional class.  Values for this enum:
        kSelectMeshVerts
        kSelectMeshFaces
        kSelectSubdivMeshMaps
        kSelectOrientationLocators
        kSelectCollisionModels
        kSelectComponentsMask
        kSelectMeshComponents
        kSelectNRigids
        kSelectRigidConstraints
        kSelectCurveKnots
        kSelectEmitters
        kSelectAnimKeyframes
        kSelectTemplates
        kSelectPointsOnCurvesForGravity
        kSelectIsoparms
        kSelectJoints
        kSelectMeshLines
        kSelectParticles
        kSelectTextures
        kSelectSurfaceRange
        kSelectObjectsMask
        kSelectIkHandles
        kSelectSketchPlanes
        kSelectLocalAxis
        kSelectSubdivMeshPoints
        kSelectParticleShapes
        kSelectDynamicConstraints
        kSelectAnimAny
        kSelectMeshUVs
        kSelectFacets
        kSelectGuideLines
        kSelectHairSystems
        kSelectFields
        kSelectLights
        kSelectCVs
        kSelectManipulators
        kSelectPivots
        kSelectCurves
        kSelectObjectGroups
        kSelectSurfaces
        kSelectLattices
        kSelectXYZLocators
        kSelectCameras
        kSelectJointPivots
        kSelectCurveParmPoints
        kSelectNurbsSurfaces
        kSelectSurfaceKnots
        kSelectUVLocators
        kSelectSurfaceParmPoints
        kSelectSelectHandles
        kSelectPointsForGravity
        kSelectNurbsCurves
        kSelectPPStrokes
        kSelectMeshes
        kSelectSubdivMeshEdges
        kSelectNCloths
        kSelectClusters
        kSelectRigidBodies
        kSelectVertices
        kSelectSubdiv
        kSelectFluids
        kSelectSprings
        kSelectScalePivots
        kSelectMeshFreeEdges
        kSelectAnimInTangents
        kSelectAnimMask
        kSelectFollicles
        kSelectMeshEdges
        kSelectSculpts
        kSelectHandles
        kSelectEditPoints
        kSelectIkEndEffectors
        kSelectNParticles
        kSelectPointsOnSurfacesForGravity
        kSelectHulls
        kSelectSurfaceEdge
        kSelectCurvesOnSurfaces
        kSelectAnimOutTangents
        kSelectSubdivMeshFaces
        kSelectLatticePoints
        kSelectRotatePivots
        kSelectEdges
        kSelectAnimCurves
        kSelectLocators
'''
        def __init__(self):
            pass

class MSpace:
    '''Space transformation identifiers. MSpace encompasses all of the types of transformation possible. The MSpace identifiers are used to determine the space in which the user is applying or querying transformation or component (i.e. vertex positions) data of a Maya object.Note that not all the MSpace types can be passed into all methods which take an MSpace as a parameter. The MSpace enumerated type can be split into two parts, types which can be passed into MFnTransform and MTransformationMatrix classes (kTransform, kPreTransform and kPostTransform) and types which can be passed into shape classes such as MFnMesh, MFnNurbsSurface and MFnCamera (kWorld and kObject).The following is a description of each of the MSpace types.There are four spaces in which to apply a transformation.'''
    def __init__(self):
        pass


    def kInvalid(self):
        '''This is an enum of Space.
Description: Invalid value.
Value: 0'''
        pass

    def kLast(self):
        '''This is an enum of Space.
Description: Last value, used for counting.
Value: 5'''
        pass

    def kPreTransform(self):
        '''This is an enum of Space.
Description: Pre-transform matrix (geometry).
Value: 2'''
        pass

    def kTransform(self):
        '''This is an enum of Space.
Description: Transform matrix (relative) space.
Value: 1'''
        pass

    def kPostTransform(self):
        '''This is an enum of Space.
Description: Post-transform matrix (world) space.
Value: 3'''
        pass

    def kWorld(self):
        '''This is an enum of Space.
Description: transform in world space.
Value: 4'''
        pass

    def kObject(self):
        '''This is an enum of Space.
Description: Same as pre-transform space.
Value: 2'''
        pass

    class Space:
        '''Non-functional class.  Values for this enum:
        kInvalid
        kLast
        kPreTransform
        kTransform
        kPostTransform
        kWorld
        kObject
'''
        def __init__(self):
            pass

class MStatus:
    '''Manipulate Maya Status codes. This class facilitates API level error handling. It encapsulates the status code and the internal MAYA error code as return by API functions. The user can query, set, print the error code along with the error description. '''
    def __init__(self):
        pass


    def set(self, status, statusCode, internalStatusCode): 
        '''set(self, status, statusCode, internalStatusCode)
Arguments:
	[in]	status = bool
	[in]	statusCode = char
	[in]	internalStatusCode = char


Internal use only. 
'''
        pass

    def perror(self, preString): 
        '''perror(self, preString)
Arguments:
	[in]	preString = MString


The second version of the  perror()  method. This method takes a reference to a  MString  as the parameter. It prints the error string preceded by the string supplied by the user to the standard error stream.'''
        pass

    def errorString(self): 
        '''errorString(self) -> MString


This method returns the internal error message as a  MString  object.'''
        pass

    def clear(self): 
        '''clear(self)

Clear error codes from the  MStatus  instance. After this call, it will behave as if it contained  MS::kSuccess . 
  Reprocessed example  
 Examples: 
 
   
 cgfxShaderCmd.cpp ,  cgfxShaderNode.cpp ,  filteredAsciiFile.cpp ,  helix2Cmd.cpp ,  narrowPolyViewer.cpp ,  polyPrimitiveCmd.cpp ,  splitUVCmd.cpp , and  XmlGeometryCache.cpp . 
 
'''
        pass

    def setSuccess(self): 
        '''setSuccess(self)
'''
        pass

    def kLicenseFailure(self):
        '''This is an enum of MStatusCode.
Description: Application is not licensed for the attempted operation.
Value: 4'''
        pass

    def kUnknownParameter(self):
        '''This is an enum of MStatusCode.
Description: Returned by
Value: 5'''
        pass

    def kFailure(self):
        '''This is an enum of MStatusCode.
Description: The operation failed.
Value: 1'''
        pass

    def kInvalidParameter(self):
        '''This is an enum of MStatusCode.
Description: An invalid parameter was provided.
Value: 3'''
        pass

    def kSuccess(self):
        '''This is an enum of MStatusCode.
Description: The operation was successful.
Value: 0'''
        pass

    def kEndOfFile(self):
        '''This is an enum of MStatusCode.
Description: Not currently used.
Value: 8'''
        pass

    def kInsufficientMemory(self):
        '''This is an enum of MStatusCode.
Description: The operation failed due to insufficient memory.
Value: 2'''
        pass

    def kNotFound(self):
        '''This is an enum of MStatusCode.
Description: Not currently used.
Value: 7'''
        pass

    def kNotImplemented(self):
        '''This is an enum of MStatusCode.
Description: Not currently used.
Value: 6'''
        pass

    class MStatusCode:
        '''Non-functional class.  Values for this enum:
        kLicenseFailure
        kUnknownParameter
        kFailure
        kInvalidParameter
        kSuccess
        kEndOfFile
        kInsufficientMemory
        kNotFound
        kNotImplemented
'''
        def __init__(self):
            pass

    def bool(self): 
        '''bool(self) -> MStatus.operator

'''
        pass

    def error(self): 
        '''error(self) -> bool


Determines whether there is an error.'''
        pass

    def __neq__(self, rhs): 
        '''__neq__(self, rhs) -> bool
Returns: true the object does not have the given detailed status code. 
false the object has the given detailed status code. 

Arguments:
	[in]	rhs = MStatus.MStatusCode


The not equal operator that takes a  MStatus::MStatusCode .'''
        pass

    def __eq__(self, rhs): 
        '''__eq__(self, rhs) -> bool
Returns: true the object has the given detailed status code. 
false the object does not have the given detailed status code. 

Arguments:
	[in]	rhs = MStatus.MStatusCode


The equivalence operator that takes a  MStatus::MStatusCode .'''
        pass

    def statusCode(self): 
        '''statusCode(self) -> MStatus.MStatusCode


Retrieve the type of error that occurred, as specified in the  MStatusCode  enumeration.'''
        pass

class MStreamUtils:
    '''Stream functionality. This class provides some standard stream functionality for developers working in C++ or script. Write methods are provided for writing to ASCII or binary. Read methods are only binary. '''
    def __init__(self):
        pass


    def writeCharBuffer(self, outarg, value, binary): 
        '''writeCharBuffer(self, outarg, value, binary)
Arguments:
	[in]	outarg = std.ostream
	[in]	value = char
	[in]	binary = bool


This method is used to write out a "const char*" value to an ostream.'''
        pass

    def writeChar(self, outarg, value, binary): 
        '''writeChar(self, outarg, value, binary)
Arguments:
	[in]	outarg = std.ostream
	[in]	value = char
	[in]	binary = bool


This method is used to write out a "char" value to an ostream.'''
        pass

    def readInt(self, inarg, value, binary): 
        '''readInt(self, inarg, value, binary)
Arguments:
	[in]	inarg = std.istream
	[in]	value = int
	[in]	binary = bool


This method is used to read a "int" binary value from an istream.'''
        pass

    def readFloat(self, inarg, value, binary): 
        '''readFloat(self, inarg, value, binary)
Arguments:
	[in]	inarg = std.istream
	[in]	value = float
	[in]	binary = bool


This method is used to read a "float" binary value from an istream.'''
        pass

    def writeDouble(self, outarg, value, binary): 
        '''writeDouble(self, outarg, value, binary)
Arguments:
	[in]	outarg = std.ostream
	[in]	value = double
	[in]	binary = bool


This method is used to write out a "double" value to an ostream.'''
        pass

    def readCharBuffer(self, inarg, value, length, binary): 
        '''readCharBuffer(self, inarg, value, length, binary)
Arguments:
	[in]	inarg = std.istream
	[in]	value = char
	[in]	length = int
	[in]	binary = bool


This method is used to read a "char*" binary value from an istream.'''
        pass

    def stdErrorStream(self): 
        '''stdErrorStream(self) -> std.ostream&

'''
        pass

    def writeFloat(self, outarg, value, binary): 
        '''writeFloat(self, outarg, value, binary)
Arguments:
	[in]	outarg = std.ostream
	[in]	value = float
	[in]	binary = bool


This method is used to write out a "float" value to an ostream.'''
        pass

    def stdOutStream(self): 
        '''stdOutStream(self) -> std.ostream&

'''
        pass

    def writeInt(self, outarg, value, binary): 
        '''writeInt(self, outarg, value, binary)
Arguments:
	[in]	outarg = std.ostream
	[in]	value = int
	[in]	binary = bool


This method is used to write out a "int" value to an ostream.'''
        pass

    def readDouble(self, inarg, value, binary): 
        '''readDouble(self, inarg, value, binary)
Arguments:
	[in]	inarg = std.istream
	[in]	value = double
	[in]	binary = bool


This method is used to read a "double" binary value from an istream.'''
        pass

    def readChar(self, inarg, value, binary): 
        '''readChar(self, inarg, value, binary)
Arguments:
	[in]	inarg = std.istream
	[in]	value = char
	[in]	binary = bool


This method is used to read a "char" binary value from an istream.'''
        pass

class MSyntax:
    '''Syntax for Commands. This class is used to specify flags and arguments passed to commands. Once the syntax of the command has been defined by calls to the methods in this class, Maya will be able to automatically parse invocations of the command and reject syntactically invalid ones. When the  method of the command is invoked, the provided argument list can be parsed automatically into an instance of either the MArgDatabase class (for commands) or MArgParser class (for context commands) by passing the constructor for that class both the argument list and the syntax object for the command.There are three type of arguments that can be specified via these syntax methods:  and  are incompatible and must not be combined in the syntax definition of a command. If an attempt is made to do so, neither command arguments or objects will be accessible via the MArgDatabase or MArgParser classes.The  method is used to add a flag argument to a command. Flags need to have a  specified for them from the list of available types in the MArgType enum and can take up to six parameters. Flags can be set as being allowed multiple times on the command line be calling the  method.The  method is used to add a command argument to a command. Such arguments must also have a  specified for them from the list of available types in the MArgType enum. If you specify an argument via this call, Maya will reject an invocation of the command as being syntactically invalid if an argument of the correct type is not provided. If the type  is provided, Maya will include the contents of the selection list as the argument to the command.The  method is used to specify that the command requires an object list. Parameters to this method allow you to specify minimum and maximum numbers of objects. As well, if the  method is used in conjunction with this, Maya will use the contents of the selection list as the objects for the command if none are specified.The documentation for the MArgDatabase and MArgParser classes describe how to access the parsed information for a command inside the doIt method of that command. '''
    def __init__(self):
        pass


    def kInvalidObjectFormat(self):
        '''This is an enum of MObjectFormat.
Description: 
Value: 0'''
        pass

    def kNone(self):
        '''This is an enum of MObjectFormat.
Description: 
Value: 1'''
        pass

    def kLastObjectFormat(self):
        '''This is an enum of MObjectFormat.
Description: 
Value: 4'''
        pass

    def kStringObjects(self):
        '''This is an enum of MObjectFormat.
Description: 
Value: 2'''
        pass

    def kSelectionList(self):
        '''This is an enum of MObjectFormat.
Description: 
Value: 3'''
        pass

    class MObjectFormat:
        '''Non-functional class.  Values for this enum:
        kInvalidObjectFormat
        kNone
        kLastObjectFormat
        kStringObjects
        kSelectionList
'''
        def __init__(self):
            pass

    def canQuery(self): 
        '''canQuery(self) -> bool


Returns whether or not the command supports the query flag ("-q").'''
        pass

    def makeFlagQueryWithFullArgs(self, flag, queryArgsAreOptional): 
        '''makeFlagQueryWithFullArgs(self, flag, queryArgsAreOptional)
Arguments:
	[in]	flag = char
	[in]	queryArgsAreOptional = bool


Specifies that the given flag will require all of its arguments in query mode. Usually flags do not take arguments in query mode, since you are getting values instead of setting them. However, sometimes it is necessary to take arguments on a flag to allow the user to provide information which will help specify the scope of a query.'''
        pass

    def addFlag(self, shortName, longName, argType1, argType2, argType3, argType4, argType5, argType6): 
        '''addFlag(self, shortName, longName, argType1, argType2, argType3, argType4, argType5, argType6)
Arguments:
	[in]	shortName = char
	[in]	longName = char
	[in]	argType1 = MSyntax.MArgType
	[in]	argType2 = MSyntax.MArgType
	[in]	argType3 = MSyntax.MArgType
	[in]	argType4 = MSyntax.MArgType
	[in]	argType5 = MSyntax.MArgType
	[in]	argType6 = MSyntax.MArgType


Adds a flag to the list of flags accepted for the given command. Also specifies any arguments required by the flag.'''
        pass

    def useSelectionAsDefault(self, useSelectionList): 
        '''useSelectionAsDefault(self, useSelectionList)
Arguments:
	[in]	useSelectionList = bool


Specifies that the command will use the current selection list as arguments to the command if the command requires  objects  and none are provided}.'''
        pass

    def enableEdit(self, supportsEdit): 
        '''enableEdit(self, supportsEdit)
Arguments:
	[in]	supportsEdit = bool


Sets whether or not the command supports the edit flag ("-e").'''
        pass

    def enableQuery(self, supportsQuery): 
        '''enableQuery(self, supportsQuery)
Arguments:
	[in]	supportsQuery = bool


Sets whether or not the command supports the query flag ("-q").'''
        pass

    def addArg(self, arg): 
        '''addArg(self, arg)
Arguments:
	[in]	arg = MSyntax.MArgType


Specifies the type of one of the arguments to the command. This method can be called multiple times to specify multiple arguments to the command.'''
        pass

    def makeFlagMultiUse(self, flag): 
        '''makeFlagMultiUse(self, flag)
Arguments:
	[in]	flag = char


Specifies that the given flag can be used by the command multiple times in on the same command line.'''
        pass

    def minObjects(self): 
        '''minObjects(self) -> int


Returns the lower limit on the number of objects accepted by the command.'''
        pass

    def setMaxObjects(self, maximumObjectCount): 
        '''setMaxObjects(self, maximumObjectCount)
Arguments:
	[in]	maximumObjectCount = int


Specifies the upper limit on the number of objects accepted by the command.'''
        pass

    def maxObjects(self): 
        '''maxObjects(self) -> int


Returns the upper limit on the number of objects accepted by the command.'''
        pass

    def setMinObjects(self, minimumObjectCount): 
        '''setMinObjects(self, minimumObjectCount)
Arguments:
	[in]	minimumObjectCount = int


Specifies the lower limit on the number of objects accepted by the command.'''
        pass

    class MArgType:
        '''Non-functional class.  Values for this enum:
'''
        def __init__(self):
            pass

    def setObjectType(self, objectFormat, minimumObjects, maximumObjects): 
        '''setObjectType(self, objectFormat, minimumObjects, maximumObjects)
Arguments:
	[in]	objectFormat = MSyntax.MObjectFormat
	[in]	minimumObjects = int
	[in]	maximumObjects = int


Specifies the representation of the objects passed to the command as either MObjects or MStrings. Also specifies the upper and lower limits of the number of objects accepted by the command.'''
        pass

    def canEdit(self): 
        '''canEdit(self) -> bool


Returns whether or not the command supports the edit flag ("-e").'''
        pass

class MTesselationParams:
    '''Tesselation parameters. This class provides control over the tesselation operation. This class is meant to be used in conjunction with the tesselate method of MFnNurbsSurface.The tesselation operation works by building an initial mesh and then refining that mesh until certain subdivision criteria are met. This class provides control over both the method of construction of the initial mesh and also the criteria for subsequent refinement. The initial tesselation is specified by the polygon output type, and the isoparm type. The secondary tesselation (or subdivision) is specified by the tesselation format. The output type can be specified as either  or . If triangles are specified then all the polygons in the initial mesh will be triangles. If quads are specified then whenever possible the polygons will be quads. The isoparm type specifies how the initial mesh is to be built. The subdivision criteria for refinement of the initial mesh is specified as one of three formats; If the tesselation format is general then you can choose which criteria you would like to use in the tesselation. For each criterion, there is an "use" flag (in other words, is this used?) together with the data for the criterion. '''
    def __init__(self):
        pass


    def kTriangles(self):
        '''This is an enum of PolyType.
Description: 
Value: 0'''
        pass

    def kQuads(self):
        '''This is an enum of PolyType.
Description: 
Value: 1'''
        pass

    class PolyType:
        '''Non-functional class.  Values for this enum:
        kTriangles
        kQuads
'''
        def __init__(self):
            pass

    def setMinEdgeLength(self, value): 
        '''setMinEdgeLength(self, value)
Arguments:
	[in]	value = double


Sets the minimum edge length. This value is used when the subdivision criteria  kUseMinEdgeLength  has been set.'''
        pass

    def setChordHeightRatio(self, value): 
        '''setChordHeightRatio(self, value)
Arguments:
	[in]	value = double


Sets the chord height ratio. This value is used when the subdivision criteria  kUseChordHeightRatio  has been set.'''
        pass

    def setVIsoparmType(self, vValue): 
        '''setVIsoparmType(self, vValue)
Arguments:
	[in]	vValue = MTesselationParams.IsoparmType


Sets the v-isoparm type to be used in the initial tesselation.'''
        pass

    def setUIsoparmType(self, uValue): 
        '''setUIsoparmType(self, uValue)
Arguments:
	[in]	uValue = MTesselationParams.IsoparmType


Sets the u-isoparm type to be used in the initial tesselation.'''
        pass

    def kGeneralFormat(self):
        '''This is an enum of TessFormat.
Description: 
Value: 2'''
        pass

    def kTriangleCountFormat(self):
        '''This is an enum of TessFormat.
Description: 
Value: 0'''
        pass

    def kStandardFitFormat(self):
        '''This is an enum of TessFormat.
Description: 
Value: 1'''
        pass

    class TessFormat:
        '''Non-functional class.  Values for this enum:
        kGeneralFormat
        kTriangleCountFormat
        kStandardFitFormat
'''
        def __init__(self):
            pass

    def setEdgeSmoothFactor(self, smoothness): 
        '''setEdgeSmoothFactor(self, smoothness)
Arguments:
	[in]	smoothness = double


Sets the edge smoothness factor used for the Edge Smooth secondary tesselation criteria.'''
        pass

    def setBoundingBoxDiagonal(self, distance): 
        '''setBoundingBoxDiagonal(self, distance)
Arguments:
	[in]	distance = double


Sets the diagonal distance of the bounding box of the surface.'''
        pass

    def setVDistanceFraction(self, value): 
        '''setVDistanceFraction(self, value)
Arguments:
	[in]	value = double


Sets the fraction of the 3D surface bounding box diagonal for the kSurface3DDistance isoparm type. The value is 0.0 for other types.'''
        pass

    def setStdFractionalTolerance(self, value): 
        '''setStdFractionalTolerance(self, value)
Arguments:
	[in]	value = double


Sets the fractional tolerance which is used when the tesselation format is  kStandardFitFormat .'''
        pass

    def setMaxUVRectangleSize(self, u, v): 
        '''setMaxUVRectangleSize(self, u, v)
Arguments:
	[in]	u = double
	[in]	v = double


Sets the maximum polygon size in uv-space for secondary tesselation. Polygons will be greater than the specified size.'''
        pass

    def setUDistanceFraction(self, value): 
        '''setUDistanceFraction(self, value)
Arguments:
	[in]	value = double


Sets the fraction of the 3D surface bounding box diagonal for the kSurface3DDistance isoparm type. The value is 0.0 for other types.'''
        pass

    def setStdChordHeightRatio(self, value): 
        '''setStdChordHeightRatio(self, value)
Arguments:
	[in]	value = double


Sets the chord height ratio which is used when the tesselation format is  kStandardFitFormat .'''
        pass

    def setOutputType(self, outputType): 
        '''setOutputType(self, outputType)
Arguments:
	[in]	outputType = MTesselationParams.PolyType


Specifies the type of polygons in the tesselated object.'''
        pass

    def setStdMinEdgeLength(self, value): 
        '''setStdMinEdgeLength(self, value)
Arguments:
	[in]	value = double


Sets the minimum edge length which is used when the tesselation format is  kStandardFitFormat .'''
        pass

    def setUNumber(self, count): 
        '''setUNumber(self, count)
Arguments:
	[in]	count = int


This is the number of u isoparms used in the initial tesselation. This value is only used for kSurface3DEquiSpaced, kSurfaceEquiSpaced, and kSpanEquiSpaced isoparm types.'''
        pass

    def set3DDelta(self, delta): 
        '''set3DDelta(self, delta)
Arguments:
	[in]	delta = double


Sets the fraction of the box diagonal to be used as 3-d spacing for u- and v-isoparams on face/surface to make up the initial grid for the mesh. This is used when the tesselation format is  kStandardFitFormat .'''
        pass

    def setMaxNumberPolys(self, value): 
        '''setMaxNumberPolys(self, value)
Arguments:
	[in]	value = int


Sets the maximum number of polygons. This value is used when the subdivision criteria  kUseMaxNumberPolys  has been set.'''
        pass

    def setFormatType(self, format): 
        '''setFormatType(self, format)
Arguments:
	[in]	format = MTesselationParams.TessFormat


Sets the tesselation format. The tesselation format is used in the secondary tesselation stage to specify the subdivision criteria used in refining the initial mesh.'''
        pass

    def setRelativeFitTolerance(self, value): 
        '''setRelativeFitTolerance(self, value)
Arguments:
	[in]	value = double


Sets the relative fit tolerance. This value is used when the subdivision criteria  kUseRelativeTolerance  has been set.'''
        pass

    def kSurface3DDistance(self):
        '''This is an enum of IsoparmType.
Description: 
Value: 0'''
        pass

    def kSurfaceEquiSpaced(self):
        '''This is an enum of IsoparmType.
Description: 
Value: 2'''
        pass

    def kSpanEquiSpaced(self):
        '''This is an enum of IsoparmType.
Description: 
Value: 3'''
        pass

    def kSurface3DEquiSpaced(self):
        '''This is an enum of IsoparmType.
Description: 
Value: 1'''
        pass

    class IsoparmType:
        '''Non-functional class.  Values for this enum:
        kSurface3DDistance
        kSurfaceEquiSpaced
        kSpanEquiSpaced
        kSurface3DEquiSpaced
'''
        def __init__(self):
            pass

    def setSubdivisionFlag(self, subType, use): 
        '''setSubdivisionFlag(self, subType, use)
Arguments:
	[in]	subType = MTesselationParams.SubdivisionType
	[in]	use = bool


Sets the types of subdivision used when the tesselation format is general. This method allows you to set the types of subdivision to be performed after the initial mesh is created. The  use  flag specifies whether to use the given subdivision type in the secondary tesselation.'''
        pass

    def setTriangleCount(self, count): 
        '''setTriangleCount(self, count)
Arguments:
	[in]	count = int


Sets the approximate number of triangles for the tesselated object when the format is  kTriangleCountFormat .'''
        pass

    def setMaxEdgeLength(self, value): 
        '''setMaxEdgeLength(self, value)
Arguments:
	[in]	value = double


Sets the maximum edge length. This value is used when the subdivision criteria  kUseMaxEdgeLength  has been set.'''
        pass

    def setVNumber(self, count): 
        '''setVNumber(self, count)
Arguments:
	[in]	count = int


This is the number of v isoparms used in the initial tesselation. This value is only used for kSurface3DEquiSpaced, kSurfaceEquiSpaced, and kSpanEquiSpaced isoparm types.'''
        pass

    def setWorldspaceToScreenTransform(self, value): 
        '''setWorldspaceToScreenTransform(self, value)
Arguments:
	[in]	value = MMatrix


The transformation matrix used in the minimum screen size test for subdivision. This value is used when the subdivision criteria  kUseMinScreenSize  has been set.'''
        pass

    def setFitTolerance(self, value): 
        '''setFitTolerance(self, value)
Arguments:
	[in]	value = double


Sets the absolute fit tolerance. This value is used when the subdivision criteria  kUseFractionalTolerance  has been set.'''
        pass

    def kUseRelativeTolerance(self):
        '''This is an enum of SubdivisionType.
Description: 
Value: 9'''
        pass

    def kUseMaxSubdivisionLevel(self):
        '''This is an enum of SubdivisionType.
Description: 
Value: 5'''
        pass

    def kUseEdgeSmooth(self):
        '''This is an enum of SubdivisionType.
Description: 
Value: 10'''
        pass

    def kUseMaxEdgeLength(self):
        '''This is an enum of SubdivisionType.
Description: 
Value: 3'''
        pass

    def kUseTriangleEdgeSwapping(self):
        '''This is an enum of SubdivisionType.
Description: 
Value: 8'''
        pass

    def kUseMaxUVRectangleSize(self):
        '''This is an enum of SubdivisionType.
Description: 
Value: 7'''
        pass

    def kUseFractionalTolerance(self):
        '''This is an enum of SubdivisionType.
Description: 
Value: 0'''
        pass

    def kUseMaxNumberPolys(self):
        '''This is an enum of SubdivisionType.
Description: 
Value: 4'''
        pass

    def kUseChordHeightRatio(self):
        '''This is an enum of SubdivisionType.
Description: 
Value: 1'''
        pass

    def kUseMinEdgeLength(self):
        '''This is an enum of SubdivisionType.
Description: 
Value: 2'''
        pass

    def kUseMinScreenSize(self):
        '''This is an enum of SubdivisionType.
Description: 
Value: 6'''
        pass

    def kLastFlag(self):
        '''This is an enum of SubdivisionType.
Description: 
Value: 11'''
        pass

    class SubdivisionType:
        '''Non-functional class.  Values for this enum:
        kUseRelativeTolerance
        kUseMaxSubdivisionLevel
        kUseEdgeSmooth
        kUseMaxEdgeLength
        kUseTriangleEdgeSwapping
        kUseMaxUVRectangleSize
        kUseFractionalTolerance
        kUseMaxNumberPolys
        kUseChordHeightRatio
        kUseMinEdgeLength
        kUseMinScreenSize
        kLastFlag
'''
        def __init__(self):
            pass

    def setMaxSubdivisionLevel(self, value): 
        '''setMaxSubdivisionLevel(self, value)
Arguments:
	[in]	value = double


Sets the maximum subdivision level. This value is used when the subdivision criteria  kUseMaxSubdivisionLevel  has been set.'''
        pass

    def setMinScreenSize(self, x, y): 
        '''setMinScreenSize(self, x, y)
Arguments:
	[in]	x = double
	[in]	y = double


If polygons are smaller than the specified screen size then the subdivision will not proceed. These values are used when the subdivision criteria  kUseMinScreenSize  has been set.'''
        pass

class MTime:
    '''Set and retrieve animation time values in various unit systems. The MTime class provides a fundamental type for the Maya API to hold and manipulate animation timing information in various unit systems. All API methods that require or return timing information do so through variables of this type.If one desires to manipulate time in such a way that integer changes in an MTime instance result in integer changes in the  displayed by the timeslider, then an MTime instance should be created that uses  units. This can be done either by using the default constructor, or by passing the return value of the static method  to the normal constructor. Once such an MTime instance is created, its value will be equivalent to a  on the timeslider.It should be noted that while the timeslider displays , a seemingly unitless value, Maya internally is operating based on the desired  (one of those specified by the MTime::Unit enum. It is necessary for the API programmer to be aware of this as MTime instances are  unitless and allow the manipulation of time in any desired units. '''
    def __init__(self):
        pass


    def setValue(self, newValue): 
        '''setValue(self, newValue)
Arguments:
	[in]	newValue = double


Set the current time value in the current units for this instance.'''
        pass

    def setUIUnit(self, newUnit): 
        '''setUIUnit(self, newUnit)
Arguments:
	[in]	newUnit = MTime.Unit


Set the unit system to be used by the user in the UI. After the successful completion of this method, Maya's timeslider will be displaying  frames  in the specified units.'''
        pass

    def __rmult__(self, rhs): 
        '''__rmult__(self, rhs) -> MTime

Arguments:
	[in]	rhs = double


In place multiplication by a scalar operator. Multiply the current instance by the given double.'''
        pass

    def uiUnit(self): 
        '''uiUnit(self) -> MTime.Unit


Returns the Working Units (or UI units) chosen in the settings of the prefs window. Maya's timeslider displays  frames  in these units.'''
        pass

    def __div__(self, rhs): 
        '''__div__(self, rhs) -> MTime

Arguments:
	[in]	rhs = double


Division by a scalar operator. Divide the instance to the left of the / operator by the given double, and assign the result to a new  MTime  instance.'''
        pass

    def value(self): 
        '''value(self) -> double


Returns the current time value in the units that are currently in effect for this instance.'''
        pass

    def __radd__(self, rhs): 
        '''__radd__(self, rhs) -> MTime

Arguments:
	[in]	rhs = double

'''
        pass

    def as(self, newUnit): 
        '''as(self, newUnit) -> double
Returns: The current time value in the given units 

Arguments:
	[in]	newUnit = MTime.Unit


Returns the current time value in the given units. This does not affect the current units for the instance.'''
        pass

    def __mul__(self, rhs): 
        '''__mul__(self, rhs) -> MTime

Arguments:
	[in]	rhs = double


Multiplication by a scalar operator. Multiply the instance to the left of the * operator by the given double, and assign the result to a new  MTime  instance.'''
        pass

    def __rsub__(self, rhs): 
        '''__rsub__(self, rhs) -> MTime

Arguments:
	[in]	rhs = double

'''
        pass

    def k120FPS(self):
        '''This is an enum of Unit.
Description: 120 frames per second
Value: 26'''
        pass

    def k100FPS(self):
        '''This is an enum of Unit.
Description: 100 frames per second
Value: 25'''
        pass

    def k750FPS(self):
        '''This is an enum of Unit.
Description: 750 frames per second
Value: 37'''
        pass

    def k4FPS(self):
        '''This is an enum of Unit.
Description: 4 frames per second
Value: 14'''
        pass

    def k250FPS(self):
        '''This is an enum of Unit.
Description: 250 frames per second
Value: 31'''
        pass

    def kUserDef(self):
        '''This is an enum of Unit.
Description: user defined units (not implemented yet)
Value: 43'''
        pass

    def k10FPS(self):
        '''This is an enum of Unit.
Description: 10 frames per second
Value: 18'''
        pass

    def k150FPS(self):
        '''This is an enum of Unit.
Description: 150 frames per second
Value: 28'''
        pass

    def kNTSCFrame(self):
        '''This is an enum of Unit.
Description: 30 frames per second
Value: 8'''
        pass

    def k400FPS(self):
        '''This is an enum of Unit.
Description: 400 frames per second
Value: 34'''
        pass

    def k75FPS(self):
        '''This is an enum of Unit.
Description: 75 frames per second
Value: 23'''
        pass

    def kFilm(self):
        '''This is an enum of Unit.
Description: 24 frames per second
Value: 6'''
        pass

    def k1500FPS(self):
        '''This is an enum of Unit.
Description: 1500 frames per second
Value: 39'''
        pass

    def k300FPS(self):
        '''This is an enum of Unit.
Description: 300 frames per second
Value: 32'''
        pass

    def k600FPS(self):
        '''This is an enum of Unit.
Description: 600 frames per second
Value: 36'''
        pass

    def k6000FPS(self):
        '''This is an enum of Unit.
Description: 6000 frames per second
Value: 42'''
        pass

    def k16FPS(self):
        '''This is an enum of Unit.
Description: 16 frames per second
Value: 20'''
        pass

    def kShowScan(self):
        '''This is an enum of Unit.
Description: twice the speed of film (48 frames per second)
Value: 9'''
        pass

    def kNTSCField(self):
        '''This is an enum of Unit.
Description: twice the speed of NTSC (60 frames per second)
Value: 11'''
        pass

    def k3FPS(self):
        '''This is an enum of Unit.
Description: 3 frames per second
Value: 13'''
        pass

    def k1200FPS(self):
        '''This is an enum of Unit.
Description: 1200 frames per second
Value: 38'''
        pass

    def k375FPS(self):
        '''This is an enum of Unit.
Description: 375 frames per second
Value: 33'''
        pass

    def k12FPS(self):
        '''This is an enum of Unit.
Description: 12 frames per second
Value: 19'''
        pass

    def k40FPS(self):
        '''This is an enum of Unit.
Description: 40 frames per second
Value: 22'''
        pass

    def kPALField(self):
        '''This is an enum of Unit.
Description: twice the speed of PAL (50 frames per second)
Value: 10'''
        pass

    def kMilliseconds(self):
        '''This is an enum of Unit.
Description: 1/1000 of a second
Value: 4'''
        pass

    def k5FPS(self):
        '''This is an enum of Unit.
Description: 5 frames per second
Value: 15'''
        pass

    def k500FPS(self):
        '''This is an enum of Unit.
Description: 500 frames per second
Value: 35'''
        pass

    def kLast(self):
        '''This is an enum of Unit.
Description: Last value, used for counting.
Value: 44'''
        pass

    def k8FPS(self):
        '''This is an enum of Unit.
Description: 8 frames per second
Value: 17'''
        pass

    def kGames(self):
        '''This is an enum of Unit.
Description: 15 frames per second
Value: 5'''
        pass

    def k20FPS(self):
        '''This is an enum of Unit.
Description: 20 frames per second
Value: 21'''
        pass

    def kInvalid(self):
        '''This is an enum of Unit.
Description: Invalid value.
Value: 0'''
        pass

    def kMinutes(self):
        '''This is an enum of Unit.
Description: 60 seconds
Value: 2'''
        pass

    def k80FPS(self):
        '''This is an enum of Unit.
Description: 80 frames per second
Value: 24'''
        pass

    def kHours(self):
        '''This is an enum of Unit.
Description: 3600 seconds
Value: 1'''
        pass

    def k3000FPS(self):
        '''This is an enum of Unit.
Description: 3000 frames per second
Value: 41'''
        pass

    def k2FPS(self):
        '''This is an enum of Unit.
Description: 2 frames per second
Value: 12'''
        pass

    def kSeconds(self):
        '''This is an enum of Unit.
Description: 1 second
Value: 3'''
        pass

    def k125FPS(self):
        '''This is an enum of Unit.
Description: 125 frames per second
Value: 27'''
        pass

    def k200FPS(self):
        '''This is an enum of Unit.
Description: 200 frames per second
Value: 29'''
        pass

    def kPALFrame(self):
        '''This is an enum of Unit.
Description: 25 frames per second
Value: 7'''
        pass

    def k6FPS(self):
        '''This is an enum of Unit.
Description: 6 frames per second
Value: 16'''
        pass

    def k2000FPS(self):
        '''This is an enum of Unit.
Description: 2000 frames per second
Value: 40'''
        pass

    def k240FPS(self):
        '''This is an enum of Unit.
Description: 240 frames per second
Value: 30'''
        pass

    class Unit:
        '''Non-functional class.  Values for this enum:
        k120FPS
        k100FPS
        k750FPS
        k4FPS
        k250FPS
        kUserDef
        k10FPS
        k150FPS
        kNTSCFrame
        k400FPS
        k75FPS
        kFilm
        k1500FPS
        k300FPS
        k600FPS
        k6000FPS
        k16FPS
        kShowScan
        kNTSCField
        k3FPS
        k1200FPS
        k375FPS
        k12FPS
        k40FPS
        kPALField
        kMilliseconds
        k5FPS
        k500FPS
        kLast
        k8FPS
        kGames
        k20FPS
        kInvalid
        kMinutes
        k80FPS
        kHours
        k3000FPS
        k2FPS
        kSeconds
        k125FPS
        k200FPS
        kPALFrame
        k6FPS
        k2000FPS
        k240FPS
'''
        def __init__(self):
            pass

    def __add__(self, rhs): 
        '''__add__(self, rhs) -> MTime

Arguments:
	[in]	rhs = double

'''
        pass

    def __rdiv__(self, rhs): 
        '''__rdiv__(self, rhs) -> MTime

Arguments:
	[in]	rhs = double


In place division by a scalar operator. Divide the current instance by the given double.'''
        pass

    def __sub__(self, rhs): 
        '''__sub__(self, rhs) -> MTime

Arguments:
	[in]	rhs = double

'''
        pass

    def __eq__(self, rhs): 
        '''__eq__(self, rhs) -> bool

Arguments:
	[in]	rhs = MTime

'''
        pass

    def setUnit(self, newUnit): 
        '''setUnit(self, newUnit)
Arguments:
	[in]	newUnit = MTime.Unit


Set the current units in effect on this  MTime  instance. Note that this method only changes the current units in the instance, it does not affect the value. So, calls to the value method before and after a call to setUnit will return the same number, however, the interpretation of that number will be different due to the change in unit systems.'''
        pass

    def unit(self): 
        '''unit(self) -> MTime.Unit


Returns the current units in effect for this instance.'''
        pass

    def __neq__(self, rhs): 
        '''__neq__(self, rhs) -> bool

Arguments:
	[in]	rhs = MTime

'''
        pass

class MTimer:
    '''This class works similar to timerX MEL command. MTimer class provides the functionality for calculating the time elapsed/consumed in executing a particular portion of the code. The portion of the code to be timed is embedded inbetween the calls to'beginTimer()' and 'endTimer()'. A call to 'elapsedTime()' gives the time spent in executing that portion of the code. The calculated time in seconds will be with 2 decimal accuracy. '''
    def __init__(self):
        pass


    def clear(self): 
        '''clear(self)
'''
        pass

    def beginTimer(self): 
        '''beginTimer(self)

The call to this function starts the timer. 
  Reprocessed example  
 Examples: 
 
   
 threadTestCmd.cpp , and  threadTestWithLocksCmd.cpp . 
 
'''
        pass

    def endTimer(self): 
        '''endTimer(self)

The call to this function ends the timer. 
  Reprocessed example  
 Examples: 
 
   
 threadTestCmd.cpp , and  threadTestWithLocksCmd.cpp . 
 
'''
        pass

    def elapsedTime(self): 
        '''elapsedTime(self) -> double


This function returns the time elapsed between the calls to beginTimer and endTimer. 
  Reprocessed example  
 Examples: 
 
   
 threadTestCmd.cpp , and  threadTestWithLocksCmd.cpp . 
 
'''
        pass

    def __eq__(self, rhs): 
        '''__eq__(self, rhs) -> bool

Arguments:
	[in]	rhs = MTimer


Equality operator. Checks whether the start time and end time are same.'''
        pass

    def __neq__(self, rhs): 
        '''__neq__(self, rhs) -> bool

Arguments:
	[in]	rhs = MTimer


InEquality operator.'''
        pass

class MTimerMessage:
    '''Register callbacks that are based on a fixed time interval. This class is used to register callbacks that are called at fixed time intervals. Unlike other callbacks, a timer callback is executed with the highest priority within Maya and take precidence over *all* other Maya events. Use with care as it is possible to construct a callback that will prevent any other part of Maya from running.The add callback method returns an id which is used to remove the callback.To remove a callback use MMessage::removeCallback.All callbacks that are registered by a plug-in must be removed by that plug-in when it is unloaded. Failure to do so will result in a fatal error. '''
    def __init__(self):
        pass


    def addTimerCallback(self, period, func, clientData): 
        '''addTimerCallback(self, period, func, clientData) -> MCallbackId
Returns: Identifier used for removing the callback.

Arguments:
	[in]	period = float
	[in]	func = MMessage.MElapsedTimeFunction
	[in]	clientData = void


This method registers a callback for timed messages. The maximum resolution for this callback is about 1ms. The response is, however, not guaranteed because while multitasking, the OS may delay for an unspecified length of time before returning control to Maya.'''
        pass

    def setSleepCallback(self, sleepFunc): 
        '''setSleepCallback(self, sleepFunc)
Arguments:
	[in]	sleepFunc = sleepCallbackPtr


The sleep function is a mechanism that allows the user to limit the ammount of CPU time that Maya uses while a timer callback is registered. Normally, registering a timer callback will cause Maya's event loop to run continuously and consume 100% of the available processor time. In some cases it may be desireable to use a sleep callback that will put Maya's event loop to sleep for a few miliseconds if there are no pending events. This will give another process time to do some other task.'''
        pass

    def sleepCallback(self): 
        '''sleepCallback(self) -> MTimerMessage.sleepCallbackPtr

'''
        pass

class MTimeArray:
    '''Array of MTime data type. This class implements an array of MTimes. Common convenience functions are available, and the implementation is compatible with the internal Maya implementation so that it can be passed efficiently between plugins and internal maya data structures. '''
    def __init__(self):
        pass


    def insert(self, element, index): 
        '''insert(self, element, index)
Arguments:
	[in]	element = MTime
	[in]	index = int


Inserts a new value into the array at the given index. The initial element at that index, and all following elements, are shifted towards the last. If the array cannot be expanded in size by 1 element, then the insert will fail and the existing array will remain unchanged.'''
        pass

    def set(self, element, index): 
        '''set(self, element, index)
Arguments:
	[in]	element = MTime
	[in]	index = int


Sets the value of the indicated element to the indicated  MTime  value.'''
        pass

    def clear(self): 
        '''clear(self)

Clear the contents of the array. After this operation the length method will return 0. This does not change the amount of memory allocated to the array, only the number of valid elements in it.'''
        pass

    def sizeIncrement(self): 
        '''sizeIncrement(self) -> int


Return the size by which the array will be expanded whenever expansion is necessary.'''
        pass

    def remove(self, index): 
        '''remove(self, index)
Arguments:
	[in]	index = int


Remove the array element at the given index. All array elements following the removed element are shifted toward the first element.'''
        pass

    def length(self): 
        '''length(self) -> int


Returns the number of elements in the instance.'''
        pass

    def setSizeIncrement(self, newIncrement): 
        '''setSizeIncrement(self, newIncrement)
Arguments:
	[in]	newIncrement = int


Set the size by which the array will be expanded whenever expansion is necessary.'''
        pass

    def MTime(self, index): 
        '''MTime(self, index) -> const
Returns: A reference to the indicated element 

Arguments:
	[in]	index = int


Index operator. Returns the value of the element at the given index. No range checking is done - valid indices are 0 to  length() -1.'''
        pass

    def setLength(self, length): 
        '''setLength(self, length)
Arguments:
	[in]	length = int


Set the length of the array. This will grow and shrink the array as desired. Elements that are grown have uninitialized values, while those which are shrunk will lose the data contained in the deleted elements (ie. it will release the memory).'''
        pass

    def append(self, element): 
        '''append(self, element)
Arguments:
	[in]	element = MTime


Adds a new element to the end of the array. If the array cannot be expanded in size by 1 element, then the append will fail and the existing array will remain unchanged.'''
        pass

class MTransformationMatrix:
    '''Transformation matrix. An MTransformationMatrix allows the manipulation of the individual transformation components (eg scale, rotation, shear, etc) of a four by four transformation matrix.The transformation in the node is represented as a 4x4 transformation matrix. This class allows access to the whole matrix, or the individual components (eg scale, rotation, shear, etc) of the transformation. This breakdown provides animators fine control over the animation of these parameters. Therefore, it is necessary to describe the order in which these attributes are applied to build the final matrix attribute.A transformation matrix is composed of the following components:Note that the default RotationOrder is kXYZ.The matrices are post-multiplied in Maya. For example, to transform a point P from object-space to world-space (P') you would need to post-multiply by the worldMatrix. (P' = P x WM)The transformation matrix is then constructed as follows:where 'x' denotes matrix multiplication and '-1' denotes matrix inversion'''
    def __init__(self):
        pass


    def addRotationQuaternion(self, x, y, z, w, space): 
        '''addRotationQuaternion(self, x, y, z, w, space)
Arguments:
	[in]	x = double
	[in]	y = double
	[in]	z = double
	[in]	w = double
	[in]	space = MSpace.Space


Add to the rotation component by rotating relative to the existing transformation. Rotation is a quaternion. The only valid transformation spaces for this method are  MSpace::kTransform  and  MSpace::kPreTransform . All other spaces are treated as being equivalent to  MSpace::kTransform .'''
        pass

    def scalePivot(self, space): 
        '''scalePivot(self, space) -> MPoint
Returns: Scale pivot point

Arguments:
	[in]	space = MSpace.Space


Returns the pivot around which the scale is applied.'''
        pass

    def setScale(self, scale, space): 
        '''setScale(self, scale, space)
Arguments:
	[in]	scale = double3
	[in]	space = MSpace.Space


Set the scale component of the transformation matrix.'''
        pass

    def getTranslation(self, space): 
        '''getTranslation(self, space) -> MVector
Returns: Translation vector in centimeters

Arguments:
	[in]	space = MSpace.Space


Returns the translation component of the translation as a vector in centimeters.'''
        pass

    def getRotation(self, rot, order): 
        '''getRotation(self, rot, order)
Arguments:
	[out]	rot = double3
	[out]	order = MTransformationMatrix.RotationOrder


Get the rotation component of the transformation matrix in radians. The rotation is retrieved in  MSpace::kTransform  space.'''
        pass

    def rotateTo(self, e): 
        '''rotateTo(self, e) -> MTransformationMatrix
Returns: A reference to the resulting transformation matrix 

Arguments:
	[in]	e = MEulerRotation


Sets the rotation component of the transformation matrix using an euler rotation. The rotation is performed in  MSpace::kTransform  space.'''
        pass

    def getShear(self, space, shear): 
        '''getShear(self, space, shear)
Arguments:
	[out]	shear = double3
	[in]	space = MSpace.Space


Get the shear component of the transformation matrix.'''
        pass

    def addTranslation(self, vector, space): 
        '''addTranslation(self, vector, space)
Arguments:
	[in]	vector = MVector
	[in]	space = MSpace.Space


Add to the translation component by translating relative to the existing transformation.'''
        pass

    def rotation(self): 
        '''rotation(self) -> MQuaternion


Returns the rotation component of the transformation matrix as a quaternion. The rotation is returned in  MSpace::kTransform  space.'''
        pass

    def __neq__(self, other): 
        '''__neq__(self, other) -> bool
Returns: True if not equal 

Arguments:
	[in]	other = MTransformationMatrix


Inequality operator.'''
        pass

    def setScalePivot(self, point, space, balance): 
        '''setScalePivot(self, point, space, balance)
Arguments:
	[in]	point = MPoint
	[in]	space = MSpace.Space
	[in]	balance = bool


Set the pivot around which the scale is applied.'''
        pass

    def reorderRotation(self, order): 
        '''reorderRotation(self, order)
Arguments:
	[in]	order = MTransformationMatrix.RotationOrder


Reorders the x, y, and z components of the rotation of this transform. The overall rotation will remain the same. This operation is not unique, so spin information will be lost.'''
        pass

    def asMatrixInverse(self): 
        '''asMatrixInverse(self) -> MMatrix


Returns the inverse of the four by four matrix that describes this transformation.'''
        pass

    def rotatePivot(self, space): 
        '''rotatePivot(self, space) -> MPoint
Returns: Rotation pivot point

Arguments:
	[in]	space = MSpace.Space


Returns the pivot around which the rotation is applied.'''
        pass

    def setRotatePivotTranslation(self, vector, space): 
        '''setRotatePivotTranslation(self, vector, space)
Arguments:
	[in]	vector = MVector
	[in]	space = MSpace.Space


Set the pivot translation. This component is used to preserve existing transformations when moving pivot. This method will only be useful to advanced users.'''
        pass

    def addScale(self, scale, space): 
        '''addScale(self, scale, space)
Arguments:
	[in]	scale = double3
	[in]	space = MSpace.Space


Add to the scale component by scaling relative to the existing transformation.'''
        pass

    def rotatePivotTranslation(self, space): 
        '''rotatePivotTranslation(self, space) -> MVector
Returns: Scale pivot translation

Arguments:
	[in]	space = MSpace.Space


Returns the rotation pivot translation. This is the translation that is used to compensate for the movement of the rotation pivot.'''
        pass

    def setToRotationAxis(self, axis, rotation): 
        '''setToRotationAxis(self, axis, rotation)
Arguments:
	[in]	axis = MVector
	[in]	rotation = double


Sets the rotation given an axis and a rotation about it.'''
        pass

    def rotateBy(self, e, space): 
        '''rotateBy(self, e, space) -> MTransformationMatrix
Returns: A reference to the resulting transformation matrix

Arguments:
	[in]	e = MEulerRotation
	[in]	space = MSpace.Space


Adds to the rotation component of the rotation matrix by rotating relative to the existing transformation using an euler rotation. The only valid transformation spaces for this method are  MSpace::kTransform  and  MSpace::kPreTransform /MSpacekObject. All other spaces are treated as being equivalent to  MSpace::kTransform .'''
        pass

    def asScaleMatrix(self): 
        '''asScaleMatrix(self) -> MMatrix


Returns scale space matrix. The scale space matrix takes points from object space to the space immediately following scale and shear transformations.'''
        pass

    def setRotation(self, rot, order): 
        '''setRotation(self, rot, order)
Arguments:
	[in]	rot = double3
	[in]	order = MTransformationMatrix.RotationOrder


Set the rotation component of the transformation matrix. The rotation is set in  MSpace::kTransform  space.'''
        pass

    def asMatrix(self, percent): 
        '''asMatrix(self, percent) -> MMatrix
Returns: The percentage matrix 

Arguments:
	[in]	percent = double


Returns a matrix that represents the specified percentage of this transformation matrix.'''
        pass

    def setTranslation(self, vector, space): 
        '''setTranslation(self, vector, space)
Arguments:
	[in]	vector = MVector
	[in]	space = MSpace.Space


Set the translation component of the transformation matrix in centimeters.'''
        pass

    def getRotationQuaternion(self, x, y, z, w): 
        '''getRotationQuaternion(self, x, y, z, w)
Arguments:
	[out]	x = double
	[out]	y = double
	[out]	z = double
	[out]	w = double


Get the rotation component of the transformation matrix as a quaternion. The rotation is retrieved in  MSpace::kTransform  space.'''
        pass

    def rotationOrder(self): 
        '''rotationOrder(self) -> MTransformationMatrix.RotationOrder
Returns: Rotation order


Returns the rotation order for the transform matrix. That is the order in which the Euler angles are applied to create the end rotation.'''
        pass

    def setRotatePivot(self, point, space, balance): 
        '''setRotatePivot(self, point, space, balance)
Arguments:
	[in]	point = MPoint
	[in]	space = MSpace.Space
	[in]	balance = bool


Set the pivot around which the rotation is applied.'''
        pass

    def scalePivotTranslation(self, space): 
        '''scalePivotTranslation(self, space) -> MVector
Returns: Scale pivot translation

Arguments:
	[in]	space = MSpace.Space


Returns the scale pivot translation. This is the translation that is used to compensate for the movement of the scale pivot.'''
        pass

    def addRotation(self, rot, order, space): 
        '''addRotation(self, rot, order, space)
Arguments:
	[in]	rot = double3
	[in]	order = MTransformationMatrix.RotationOrder
	[in]	space = MSpace.Space


Add to the rotation component by rotating relative to the existing transformation. The only valid transformation spaces for this method are  MSpace::kTransform  and  MSpace::kPreTransform . All other spaces are treated as being equivalent to  MSpace::kTransform .'''
        pass

    def setRotationOrientation(self, q): 
        '''setRotationOrientation(self, q) -> MTransformationMatrix

Arguments:
	[in]	q = MQuaternion


Sets the rotation orientation for the transformation matrix. The rotation orientation is the rotation that orients the local rotation space. The rotation is set in  MSpace::kTransform  space.'''
        pass

    def addShear(self, shear, space): 
        '''addShear(self, shear, space)
Arguments:
	[in]	shear = double3
	[in]	space = MSpace.Space


Add to the shear component by shearing relative to the existing transformation.'''
        pass

    def getScale(self, space, scale): 
        '''getScale(self, space, scale)
Arguments:
	[out]	scale = double3
	[in]	space = MSpace.Space


Get the scale component of the transformation matrix.'''
        pass

    def __eq__(self, other): 
        '''__eq__(self, other) -> bool
Returns: True if equal 

Arguments:
	[in]	other = MTransformationMatrix


Equality operator.'''
        pass

    def kInvalid(self):
        '''This is an enum of RotationOrder.
Description: 
Value: 0'''
        pass

    def kZXY(self):
        '''This is an enum of RotationOrder.
Description: 
Value: 3'''
        pass

    def kXYZ(self):
        '''This is an enum of RotationOrder.
Description: 
Value: 1'''
        pass

    def kYZX(self):
        '''This is an enum of RotationOrder.
Description: 
Value: 2'''
        pass

    def kYXZ(self):
        '''This is an enum of RotationOrder.
Description: 
Value: 5'''
        pass

    def kLast(self):
        '''This is an enum of RotationOrder.
Description: 
Value: 7'''
        pass

    def kXZY(self):
        '''This is an enum of RotationOrder.
Description: 
Value: 4'''
        pass

    def kZYX(self):
        '''This is an enum of RotationOrder.
Description: 
Value: 6'''
        pass

    class RotationOrder:
        '''Non-functional class.  Values for this enum:
        kInvalid
        kZXY
        kXYZ
        kYZX
        kYXZ
        kLast
        kXZY
        kZYX
'''
        def __init__(self):
            pass

    def asRotateMatrix(self): 
        '''asRotateMatrix(self) -> MMatrix


Returns rotate space matrix. The rotate space matrix takes points from object space to the space immediately following the scale/shear/rotation transformations.'''
        pass

    def rotationOrientation(self): 
        '''rotationOrientation(self) -> MQuaternion


Returns the rotation orientation for the transformation matrix. The rotation orientation is the rotation that orients the local rotation space. The rotation is returned in  MSpace::kTransform  space.'''
        pass

    def eulerRotation(self): 
        '''eulerRotation(self) -> MEulerRotation


Returns the rotation component of the transformation matrix as an euler rotation.'''
        pass

    def setShear(self, shear, space): 
        '''setShear(self, shear, space)
Arguments:
	[in]	shear = double3
	[in]	space = MSpace.Space


Set the shear component of the transformation matrix. The shear values represent (xy, xz, yx).'''
        pass

    def isEquivalent(self, other, tol): 
        '''isEquivalent(self, other, tol) -> bool
Returns: True if equivalent 

Arguments:
	[in]	other = MTransformationMatrix
	[in]	tol = double


Returns true if this transform matrix is equivalent to the one passed in within a certain tolerance.'''
        pass

    def setScalePivotTranslation(self, vector, space): 
        '''setScalePivotTranslation(self, vector, space)
Arguments:
	[in]	vector = MVector
	[in]	space = MSpace.Space


Set the pivot translation. This component is used to preserve existing scale transformations when moving pivot. This method will only be useful to advanced users.'''
        pass

    def setRotationQuaternion(self, x, y, z, w): 
        '''setRotationQuaternion(self, x, y, z, w)
Arguments:
	[in]	x = double
	[in]	y = double
	[in]	z = double
	[in]	w = double


Set the rotation component of the transformation matrix using a quaternion. The rotation is set in  MSpace::kTransform  space.'''
        pass

class MTrimBoundaryArray:
    '''An array class for trim boundaries. This class implements an array of MObjectArray objects. Each MObjectArray is a collection of curves (edges, in fact) that represent a trim boundary.This class owns all of the MObjectArrays in the class. It doesn't hold a reference to any other MObjectArray. '''
    def __init__(self):
        pass


    def insert(self, boundary, index): 
        '''insert(self, boundary, index)
Arguments:
	[in]	boundary = MObjectArray
	[in]	index = int


This method adds a new boundary into the "index" position.'''
        pass

    def set(self, boundary, index): 
        '''set(self, boundary, index)
Arguments:
	[in]	boundary = MObjectArray
	[in]	index = int


This method is used to replace an existing boundary array.'''
        pass

    def getMergedBoundary(self, index): 
        '''getMergedBoundary(self, index) -> MObject
Returns: MS::kSuccess if the curve creation worked and MS::kFailure otherwise 

Arguments:
	[in]	index = int


This function create a curve that represent all curves of the boundary. The original boundary edges are not changed. Note that the resulting curve is not added to the current model but is owned by an  MObject  which is of type kNurbsCurveData.'''
        pass

    def clear(self): 
        '''clear(self)

This method clears the trim boundary array.'''
        pass

    def remove(self, index): 
        '''remove(self, index)
Arguments:
	[in]	index = int


This method removes an existing boundary from the list.'''
        pass

    def MObjectArray(self, index): 
        '''MObjectArray(self, index) -> const
Returns: The MObjectArray requested 

Arguments:
	[in]	index = int


The method returns the  MObjectArray  specified by the index. NOTE: no bounds are checked by this method.'''
        pass

    def length(self): 
        '''length(self) -> int

'''
        pass

    def reserve(self, reserveLength): 
        '''reserve(self, reserveLength)
Arguments:
	[in]	reserveLength = int


This method is used to reserve the capacity of the array.'''
        pass

    def append(self, boundary): 
        '''append(self, boundary)
Arguments:
	[in]	boundary = MObjectArray


Add a new boundary array at the end of the list.'''
        pass

    def size(self): 
        '''size(self) -> int

'''
        pass

class MTypeId:
    '''Manage Maya Object type identifiers. In Maya, both intrinsic and user-defined Maya Objects are registered and recognized by their type identifier or type id. The basis of the type id system is a tag which is used at run-time to determine how to create and destroy Maya Objects, and how they are to be input/output from/to files. These tag-based identifiers are implemented by the class MTypeId.Use the MTypeId class to create, copy and query Maya Object type identifiers.It is very important to note that these ids are written into the Maya binary file format. So, once an id is assigned to a node or data type it can  be changed while any existing Maya file contains an instance of that node or data type. If a change is made, such files will become unreadable.Thus, even though we provide a range of reserved ids that you can use for internal plug-ins, Autodesk highly recommends that you obtain a globally unique id range (see below) and use ids from this range for all your plug-ins, even internal ones. This can prevent significant headaches later if the plans for your plug-ins change.There are 2 forms of the constructor for this class that can be used depending on whether the plug-in id is internal or globally unique.For plug-ins that will forever be internal to your site use the constructor that takes a single unsigned int parameter. The numeric range 0 - 0x7ffff (524288 ids) has been reserved for such plug-ins.The example plug-ins provided with Maya in the plug-in development kit will use ids in the range 0x80000 - 0xfffff (524288 ids). If you customize one of these example plug-ins, you should change the id to avoid future conflicts.Plug-ins that are intended to be shared between sites will need to have a globally unique id. The Autodesk Developer Network (ADN) will provide such id's in blocks of 256. You will be assigned one or more 24-bit prefixes. Once this has been obtained, used the MTypeId constructor that takes 2 unsigned int parameters. The prefix goes in the first parameter, and you are responsible for managing the allocation of the 256 ids that go into the second parameter. '''
    def __init__(self):
        pass


    def __eq__(self, rhs): 
        '''__eq__(self, rhs) -> bool
Returns: True of the two MTypeId hold the same 32-bit binary tag. 

Arguments:
	[in]	rhs = MTypeId


Equivalence operator.'''
        pass

    def id(self): 
        '''id(self) -> int
Returns: The 32-bit id tag contained in this MTypeId instance. 


Return the 32 bit id tag contained in the  MTypeId  instance'''
        pass

    def __neq__(self, rhs): 
        '''__neq__(self, rhs) -> bool
Returns: True of the two MTypeId hold different 32-bit binary tags. 

Arguments:
	[in]	rhs = MTypeId


Inequality operator.'''
        pass

class MUint64Array:
    '''Array of MUint64 data type. This class implements an array of MUint64s. Common convenience functions are available, and the implementation is compatible with the internal Maya implementation so that it can be passed efficiently between plugins and internal maya data structures. '''
    def __init__(self):
        pass


    def insert(self, element, index): 
        '''insert(self, element, index)
Arguments:
	[in]	element = MUint64
	[in]	index = int


Inserts a new value into the array at the given index. The initial element at that index, and all following elements, are shifted towards the last. If the array cannot be expanded in size by 1 element, then the insert will fail and the existing array will remain unchanged.'''
        pass

    def set(self, element, index): 
        '''set(self, element, index)
Arguments:
	[in]	element = MUint64
	[in]	index = int


Sets the value of the indicated element to the indicated MUint64 value.'''
        pass

    def get(self, array): 
        '''get(self, array)
Arguments:
	[out]	array = MUint64


Copy the elements of the array into the given C++ array of MUint64s. No checking is done to ensure that the destination C++ array of MUint64s is large enough to hold all the elements of the instance.'''
        pass

    def clear(self): 
        '''clear(self)
'''
        pass

    def sizeIncrement(self): 
        '''sizeIncrement(self) -> int


Return the size by which the array will be expanded whenever expansion is necessary.'''
        pass

    def remove(self, index): 
        '''remove(self, index)
Arguments:
	[in]	index = int


Remove the array element at the given index. All array elements following the removed element are shifted toward the first element.'''
        pass

    def length(self): 
        '''length(self) -> int


Returns the number of elements in the instance.'''
        pass

    def setSizeIncrement(self, newIncrement): 
        '''setSizeIncrement(self, newIncrement)
Arguments:
	[in]	newIncrement = int


Set the size by which the array will be expanded whenever expansion is necessary.'''
        pass

    def copy(self, source): 
        '''copy(self, source)
Arguments:
	[in]	source = MUint64Array


Copy the contents of the source array to this array.'''
        pass

    def setLength(self, length): 
        '''setLength(self, length)
Arguments:
	[in]	length = int


Set the length of the array. This will grow and shrink the array as desired. Elements that are grown have uninitialized values, while those which are shrunk will lose the data contained in the deleted elements (ie. it will release the memory).'''
        pass

    def append(self, element): 
        '''append(self, element)
Arguments:
	[in]	element = MUint64


Adds a new element to the end of the array. If the array cannot be expanded in size by 1 element, then the append will fail and the existing array will remain unchanged.'''
        pass

class MUintArray:
    '''Array of integers data type. This class implements an array of unsigned integers. Common convenience functions are available, and the implementation is compatible with the internal Maya implementation so that it can be passed efficiently between plugins and internal maya data structures. '''
    def __init__(self):
        pass


    def insert(self, element, index): 
        '''insert(self, element, index)
Arguments:
	[in]	element = int
	[in]	index = int


Inserts a new value into the array at the given index. The initial element at that index, and all following elements, are shifted towards the last. If the array cannot be expanded in size by 1 element, then the insert will fail and the existing array will remain unchanged.'''
        pass

    def set(self, element, index): 
        '''set(self, element, index)
Arguments:
	[in]	element = int
	[in]	index = int


Sets the value of the indicated element to the indicated value.'''
        pass

    def get(self, array): 
        '''get(self, array)
Arguments:
	[out]	array = int


Copy the elements of the array into the given C++ array of unsigned ints. No checking is done to ensure that the destination C++ array of ints is large enough to hold all the elements of the instance.'''
        pass

    def clear(self): 
        '''clear(self)
'''
        pass

    def sizeIncrement(self): 
        '''sizeIncrement(self) -> int


Return the size by which the array will be expanded whenever expansion is necessary.'''
        pass

    def remove(self, index): 
        '''remove(self, index)
Arguments:
	[in]	index = int


Remove the array element at the given index. All array elements following the removed element are shifted toward the first element.'''
        pass

    def length(self): 
        '''length(self) -> int


Returns the number of elements in the instance.'''
        pass

    def setSizeIncrement(self, newIncrement): 
        '''setSizeIncrement(self, newIncrement)
Arguments:
	[in]	newIncrement = int


Set the size by which the array will be expanded whenever expansion is necessary.'''
        pass

    def copy(self, source): 
        '''copy(self, source)
Arguments:
	[in]	source = MUintArray


Copy the contents of the source array to this array.'''
        pass

    def setLength(self, length): 
        '''setLength(self, length)
Arguments:
	[in]	length = int


Set the length of the array. This will grow and shrink the array as desired. Elements that are grown have uninitialized values, while those which are shrunk will lose the data contained in the deleted elements (ie. it will release the memory).'''
        pass

    def append(self, element): 
        '''append(self, element)
Arguments:
	[in]	element = int


Adds a new element to the end of the array. If the array cannot be expanded in size by 1 element, then the append will fail and the existing array will remain unchanged.'''
        pass

class MUserEventMessage:
    '''User defined Message Types. This class is used to register user-defined event types, register callbacks with the user-defined event types, and to post user-defined messages.The registerUserEvent and deregisterUserEvent methods allow user event types to be created and destroyed. User events are identified by a unique string identifier.The addCallback method registers a function that will be executed whenever the specified message occurs. An id is returned and is used to remove the callback.The postUserEvent notifies all registered callbacks of the occurence of the user-defined event.To remove a callback use MMessage::removeCallback. All callbacks that are registered by a plug-in must be removed by that plug-in when it is unloaded. Failure to do so will result in a fatal error. '''
    def __init__(self):
        pass


    def isUserEvent(self, eventName): 
        '''isUserEvent(self, eventName) -> bool
Returns: true Event type exists 
false Event type does not exist 

Arguments:
	[in]	eventName = MString


Checks if an event type exists with the given event name.'''
        pass

    def postUserEvent(self, eventName, clientData): 
        '''postUserEvent(self, eventName, clientData)
Arguments:
	[in]	eventName = MString
	[in]	clientData = void


Notifies all callbacks attached to the given event type of the occurence of the event.'''
        pass

    def deregisterUserEvent(self, eventName): 
        '''deregisterUserEvent(self, eventName)
Arguments:
	[in]	eventName = MString


Removes the event type with the given event name. If callbacks have been registered with this event type, they will become invalid after a successful call to this method.'''
        pass

    def addUserEventCallback(self, eventName, func, clientData): 
        '''addUserEventCallback(self, eventName, func, clientData) -> MCallbackId

Arguments:
	[in]	eventName = MString
	[in]	func = MMessage.MBasicFunction
	[in]	clientData = void


This method registers a callback for user-defined messages.'''
        pass

    def registerUserEvent(self, eventName): 
        '''registerUserEvent(self, eventName)
Arguments:
	[in]	eventName = MString


Adds a new event type with the given string identifier. The string identifier can then be used in all other  MUserEventMessage  methods to operate on the new event type.'''
        pass

class MVector:
    '''A vector math class for vectors of doubles. This class provides access to Maya's internal vector math library allowing vectors to be handled easily, and in a manner compatible with internal Maya data structures.All methods that query the vector are threadsafe, all methods that modify the vector are not threadsafe. '''
    def __init__(self):
        pass


    yAxis = ''
    '''Unit vector in the positive y direction. '''

    yNegAxis = ''
    '''Unit vector in the negative z direction. '''

    zNegAxis = ''
    '''Unit vector in the negative z direction. '''

    one = ''
    '''The vector <1,1,1>. '''

    xNegAxis = ''
    '''Unit vector in the negative z direction. '''

    zero = ''
    '''The null vector. '''

    zAxis = ''
    '''Unit vector in the positive z direction. '''

    xAxis = ''
    '''Unit vector in the positive x direction. '''

    def __radd__(self, other): 
        '''__radd__(self, other) -> MVector

Arguments:
	[in]	other = MVector


The in place vector addition operator.'''
        pass

    def __rsub__(self, other): 
        '''__rsub__(self, other) -> MVector

Arguments:
	[in]	other = MVector


The in place vector subtraction operator.'''
        pass

    def rotateTo(self, other): 
        '''rotateTo(self, other) -> MQuaternion
Returns: The resulting quaternion. 

Arguments:
	[out]	other = MVector


Returns the quaternion that represents the rotation of this vector into the other vector about their mutually perpendicular axis.'''
        pass

    def __rdiv__(self, scalar): 
        '''__rdiv__(self, scalar) -> MVector

Arguments:
	[in]	scalar = double


The in place division operator.'''
        pass

    def __neq__(self, other): 
        '''__neq__(self, other) -> bool
Returns: Bool false if the vectors are identical and true otherwise. 

Arguments:
	[in]	other = MVector


The vector inequality operator. This returns false if all three of the x, y, and z components are identical.'''
        pass

    def normalize(self): 
        '''normalize(self)

Performs an in place normalization of the vector'''
        pass

    def angle(self, other): 
        '''angle(self, other) -> double
Returns: The angle in radians 

Arguments:
	[in]	other = MVector


Returns the angle in radians between the vector and the one passed as an argument.'''
        pass

    def isParallel(self, other, tol): 
        '''isParallel(self, other, tol) -> bool
Returns: true if the vectors are parallel and false otherwise 

Arguments:
	[in]	other = MVector
	[in]	tol = double


Returns true if the current vector and the one passed as an argument are parallel to each other within the specified tolerance.'''
        pass

    def normal(self): 
        '''normal(self) -> MVector

'''
        pass

    def __div__(self, scalar): 
        '''__div__(self, scalar) -> MVector

Arguments:
	[in]	scalar = double


The division operator.'''
        pass

    def rotateBy(self, e): 
        '''rotateBy(self, e) -> MVector
Returns: The resulting vector. 

Arguments:
	[out]	e = MEulerRotation


Returns the vector that represents the rotation of this vector by the given euler rotation.'''
        pass

    def __getitem__(self, i): 
        '''__getitem__(self, i) -> double

Arguments:
	[in]	i = int


The index operator. If its argument is 0 it will return the x component of the vector. If its argument is 1 it will return the y component of the vector. Otherwise it will return the z component of the vector.'''
        pass

    def get(self, dest): 
        '''get(self, dest)
Arguments:
	[out]	dest = double3


Extracts the x, y, and z components of the vector and places them in elements 0, 1, and 2 of the double array passed.'''
        pass

    def isEquivalent(self, other, tol): 
        '''isEquivalent(self, other, tol) -> bool
Returns: Bool true if the vectors are equivalent and false otherwise. 

Arguments:
	[in]	other = MVector
	[in]	tol = double


Returns true if the vector and the one passed as an argument are equal to each other within the specified tolerance.'''
        pass

    def __add__(self, other): 
        '''__add__(self, other) -> MVector

Arguments:
	[in]	other = MVector


The vector addition operator.'''
        pass

    def transformAsNormal(self, matrix): 
        '''transformAsNormal(self, matrix) -> MVector
Returns: The resulting transformed vector 

Arguments:
	[in]	matrix = MMatrix


This method treats the vector as a normal vector and returns a transformed copy of the vector.'''
        pass

    def __eq__(self, other): 
        '''__eq__(self, other) -> bool
Returns: Bool true if the vectors are identical and false otherwise. 

Arguments:
	[in]	other = MVector


The vector equality operator. This returns true if all three of the x, y, and z components are identical.'''
        pass

    def __rmult__(self, right): 
        '''__rmult__(self, right) -> MVector

Arguments:
	[in]	right = MMatrix

'''
        pass

    def length(self): 
        '''length(self) -> double


Return the length of the vector. 
  Reprocessed example  
 Examples: 
 
   
 meshOpFtyAction.cpp ,  simpleFluidEmitter.cpp ,  simpleSpring.cpp , and  torusField.cpp . 
 
'''
        pass

    def __mul__(self, right): 
        '''__mul__(self, right) -> MVector

Arguments:
	[in]	right = MMatrix

'''
        pass

    def __sub__(self, other): 
        '''__sub__(self, other) -> MVector

Arguments:
	[in]	other = MVector


The vector subtraction operator.'''
        pass

    def kWaxis(self):
        '''This is an enum of Axis.
Description: 
Value: 3'''
        pass

    def kXaxis(self):
        '''This is an enum of Axis.
Description: 
Value: 0'''
        pass

    def kYaxis(self):
        '''This is an enum of Axis.
Description: 
Value: 1'''
        pass

    def kZaxis(self):
        '''This is an enum of Axis.
Description: 
Value: 2'''
        pass

    class Axis:
        '''Non-functional class.  Values for this enum:
        kWaxis
        kXaxis
        kYaxis
        kZaxis
'''
        def __init__(self):
            pass

class MVectorArray:
    '''Array of MVectors data type. This class implements an array of MVectors. Common convenience functions are available, and the implementation is compatible with the internal Maya implementation so that it can be passed efficiently between plugins and internal maya data structures. '''
    def __init__(self):
        pass


    def insert(self, element, index): 
        '''insert(self, element, index)
Arguments:
	[in]	element = MVector
	[in]	index = int


Inserts a new value into the array at the given index. The initial element at that index, and all following elements, are shifted towards the last. If the array cannot be expanded in size by 1 element, then the insert will fail and the existing array will remain unchanged.'''
        pass

    def set(self, element, index): 
        '''set(self, element, index)
Arguments:
	[in]	element = float3
	[in]	index = int


Sets the value of the indicated element to the indicated float array value.'''
        pass

    def get(self, array): 
        '''get(self, array)
Arguments:
	[out]	array = float


Copy the elements of the array into the given C++ array of float arrays. No checking is done to ensure that the destination C++ array of floats arrays is large enough to hold all the elements of the instance.'''
        pass

    def clear(self): 
        '''clear(self)

Clear the contents of the array. After this operation the length method will return 0. This does not change the amount of memory allocated to the array, only the number of valid elements in it.'''
        pass

    def MVector(self, index): 
        '''MVector(self, index) -> const
Returns: The value of the indicated element. 

Arguments:
	[in]	index = int


Index operator. Returns the value of the element at the given index. No range checking is done - valid indices are 0 to  length() -1.'''
        pass

    def remove(self, index): 
        '''remove(self, index)
Arguments:
	[in]	index = int


Remove the array element at the given index. All array elements following the removed element are shifted toward the first element.'''
        pass

    def length(self): 
        '''length(self) -> int


Returns the number of elements in the instance.'''
        pass

    def setSizeIncrement(self, newIncrement): 
        '''setSizeIncrement(self, newIncrement)
Arguments:
	[in]	newIncrement = int


Set the size by which the array will be expanded whenever expansion is necessary.'''
        pass

    def sizeIncrement(self): 
        '''sizeIncrement(self) -> int


Return the size by which the array will be expanded whenever expansion is necessary.'''
        pass

    def copy(self, source): 
        '''copy(self, source)
Arguments:
	[in]	source = MVectorArray


Copy the contents of the source array to this array.'''
        pass

    def setLength(self, length): 
        '''setLength(self, length)
Arguments:
	[in]	length = int


Set the length of the array. This will grow and shrink the array as desired. Elements that are grown have uninitialized values, while those which are shrunk will lose the data contained in the deleted elements (ie. it will release the memory).'''
        pass

    def append(self, element): 
        '''append(self, element)
Arguments:
	[in]	element = MVector


Adds a new element to the end of the array. If the array cannot be expanded in size by 1 element, then the append will fail and the existing array will remain unchanged.'''
        pass

class MWeight:
    '''Component weight data. Methods for accessing component weight data. This class is currently only used to access soft select and symmetry selection weights. Other weight data (e.g. deformer weights) does not use this class and can be accessed through the corresponding MFn class or directly from the node's attributes. '''
    def __init__(self):
        pass


    def influence(self): 
        '''influence(self) -> float


Current influence weight. 
'''
        pass

    def seam(self): 
        '''seam(self) -> float


Current seam weight. 
'''
        pass

